diff --git a/c-api/datetime.po b/c-api/datetime.po
index 276b99c83..e476d43e4 100644
--- a/c-api/datetime.po
+++ b/c-api/datetime.po
@@ -6,13 +6,15 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2018-06-28 15:29+0200\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"PO-Revision-Date: 2019-01-11 20:51+0100\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"Last-Translator: Louis Portay <lportay@student.42.fr>\n"
+"X-Generator: Poedit 2.2\n"
+"X-Poedit-Bookmarks: -1,-1,-1,-1,-1,-1,-1,3,-1,-1\n"
 
 #: ../Doc/c-api/datetime.rst:6
 msgid "DateTime Objects"
@@ -28,102 +30,139 @@ msgid ""
 "structure into a static variable, :c:data:`PyDateTimeAPI`, that is used by "
 "the following macros."
 msgstr ""
+"De nombreux objets *date* et *time* sont exposés par le module :mod:"
+"`DateTime`. Avant d'utiliser une de ces fonctions, le fichier d'en-tête :file:"
+"`datetime.h` doit être inclus dans vos sources (veuillez noter qu'il n'est "
+"pas inclus par le fichier :file:`Python.h`) et la macro :c:macro:"
+"`PyDateTime_IMPORT` doit-être invoquée, généralement lors de la fonction "
+"d'initialisation du module. La macro crée un pointeur vers une structure "
+"C et place celui-ci dans une variable statique, :c:data:`PyDateTimeAPI`, qui "
+"est utilisée par les macros suivantes."
 
 #: ../Doc/c-api/datetime.rst:16
 msgid "Macro for access to the UTC singleton:"
-msgstr ""
+msgstr "Macro pour accéder au singleton UTC :"
 
 #: ../Doc/c-api/datetime.rst:20
 msgid ""
 "Returns the time zone singleton representing UTC, the same object as :attr:"
 "`datetime.timezone.utc`."
 msgstr ""
+"Renvoie le singleton du fuseau horaire UTC, qui est le même objet que :"
+"attr:`datetime.timezone.utc`."
 
 #: ../Doc/c-api/datetime.rst:26
 msgid "Type-check macros:"
-msgstr ""
+msgstr "Macros pour vérifier les types :"
 
 #: ../Doc/c-api/datetime.rst:30
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DateType` or a subtype "
 "of :c:data:`PyDateTime_DateType`.  *ob* must not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DateType` ou un "
+"sous-type de :c:data:`PyDateTime_DateType`. *ob* ne doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:36
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DateType`. *ob* must not "
 "be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DateType`. *ob* ne doit "
+"pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:42
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DateTimeType` or a "
 "subtype of :c:data:`PyDateTime_DateTimeType`.  *ob* must not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DateTimeType` ou un "
+"sous-type de :c:data:`PyDateTime_DateTimeType`. *ob* ne doit pas être "
+"*NULL*."
 
 #: ../Doc/c-api/datetime.rst:48
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DateTimeType`. *ob* must "
 "not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DateTimeType`. *ob* ne "
+"doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:54
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_TimeType` or a subtype "
 "of :c:data:`PyDateTime_TimeType`.  *ob* must not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_TimeType` ou un sous-"
+"type de :c:data:`PyDateTime_TimeType`.  *ob* ne doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:60
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_TimeType`. *ob* must not "
 "be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_TimeType`. *ob* ne doit "
+"pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:66
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DeltaType` or a subtype "
 "of :c:data:`PyDateTime_DeltaType`.  *ob* must not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DeltaType` ou un sous-"
+"type de :c:data:`PyDateTime_DeltaType`. *ob* ne doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:72
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_DeltaType`. *ob* must not "
 "be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_DeltaType`. *ob* ne "
+"doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:78
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_TZInfoType` or a subtype "
 "of :c:data:`PyDateTime_TZInfoType`.  *ob* must not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_TZInfoType` ou un sous-"
+"type de :c:data:`PyDateTime_TZInfoType`. *ob* ne doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:84
 msgid ""
 "Return true if *ob* is of type :c:data:`PyDateTime_TZInfoType`. *ob* must "
 "not be *NULL*."
 msgstr ""
+"Renvoie vrai si *ob* est de type :c:data:`PyDateTime_TZInfoType`. *ob* ne "
+"doit pas être *NULL*."
 
 #: ../Doc/c-api/datetime.rst:88
 msgid "Macros to create objects:"
-msgstr ""
+msgstr "Macros pour créer des objets :"
 
 #: ../Doc/c-api/datetime.rst:92
 msgid ""
 "Return a :class:`datetime.date` object with the specified year, month and "
 "day."
 msgstr ""
+"Renvoie un objet :class:`datetime.date` avec l'année, le mois et le jour "
+"spécifiés."
 
 #: ../Doc/c-api/datetime.rst:97
 msgid ""
 "Return a :class:`datetime.datetime` object with the specified year, month, "
 "day, hour, minute, second and microsecond."
 msgstr ""
+"Renvoie un objet :class:`datetime.datetime` avec l'année, le mois, le jour, "
+"l'heure, la minute, la seconde et la microseconde spécifiés."
 
 #: ../Doc/c-api/datetime.rst:103
 msgid ""
 "Return a :class:`datetime.time` object with the specified hour, minute, "
 "second and microsecond."
 msgstr ""
+"Renvoie un objet :class:`datetime.time` avec l'heure, la minute, la seconde "
+"et la microseconde spécifiées."
 
 #: ../Doc/c-api/datetime.rst:109
 msgid ""
@@ -132,18 +171,26 @@ msgid ""
 "resulting number of microseconds and seconds lie in the ranges documented "
 "for :class:`datetime.timedelta` objects."
 msgstr ""
+"Renvoie un objet :class:`datetime.timedelta` représentant le nombre passé en "
+"paramètre de jours, de secondes et de microsecondes. Le résultat est "
+"normalisé pour que le nombre de microsecondes et de secondes tombe dans la "
+"plage documentée pour les objets :class:`datetime.timedelta`."
 
 #: ../Doc/c-api/datetime.rst:116
 msgid ""
 "Return a :class:`datetime.timezone` object with an unnamed fixed offset "
 "represented by the *offset* argument."
 msgstr ""
+"Renvoie un objet :class:`datetime.timezone` avec un décalage anonyme fixe "
+"représenté par l'argument *offset*."
 
 #: ../Doc/c-api/datetime.rst:123
 msgid ""
 "Return a :class:`datetime.timezone` object with a fixed offset represented "
 "by the *offset* argument and with tzname *name*."
 msgstr ""
+"Renvoie un objet :class:`datetime.timezone` avec un décalage fixe représenté "
+"par l'argument *offset* et avec le nom de fuseau horaire *name*."
 
 #: ../Doc/c-api/datetime.rst:129
 msgid ""
@@ -152,18 +199,22 @@ msgid ""
 "`PyDateTime_DateTime`).  The argument must not be *NULL*, and the type is "
 "not checked:"
 msgstr ""
+"Macros pour extraire les champs des objets *date*. L'argument doit être une "
+"instance de :c:data:`PyDateTime_Date`, ou une sous-classe (telle que :c:data:"
+"`PyDateTime_DateTime`). L'argument ne doit pas être *NULL*, et le type n'est "
+"pas vérifié :"
 
 #: ../Doc/c-api/datetime.rst:136
 msgid "Return the year, as a positive int."
-msgstr ""
+msgstr "Renvoie l'année, sous forme d'entier positif."
 
 #: ../Doc/c-api/datetime.rst:141
 msgid "Return the month, as an int from 1 through 12."
-msgstr ""
+msgstr "Renvoie le mois, sous forme d'entier allant de 1 à 12."
 
 #: ../Doc/c-api/datetime.rst:146
 msgid "Return the day, as an int from 1 through 31."
-msgstr ""
+msgstr "Renvoie le jour, sous forme d'entier allant de 1 à 31."
 
 #: ../Doc/c-api/datetime.rst:149
 msgid ""
@@ -171,22 +222,25 @@ msgid ""
 "instance of :c:data:`PyDateTime_DateTime`, including subclasses. The "
 "argument must not be *NULL*, and the type is not checked:"
 msgstr ""
+"Macros pour extraire les champs des objets *datetime*. L'argument doit être "
+"une instance de :c:data:`PyDateTime_DateTime` ou une sous-classe de celle-"
+"ci. L'argument ne doit pas être *NULL*, et le type n'est pas vérifié :"
 
 #: ../Doc/c-api/datetime.rst:155 ../Doc/c-api/datetime.rst:179
 msgid "Return the hour, as an int from 0 through 23."
-msgstr ""
+msgstr "Renvoie l'heure, sous forme d'entier allant de 0 à 23."
 
 #: ../Doc/c-api/datetime.rst:160 ../Doc/c-api/datetime.rst:184
 msgid "Return the minute, as an int from 0 through 59."
-msgstr ""
+msgstr "Renvoie la minute, sous forme d'entier allant de 0 à 59."
 
 #: ../Doc/c-api/datetime.rst:165 ../Doc/c-api/datetime.rst:189
 msgid "Return the second, as an int from 0 through 59."
-msgstr ""
+msgstr "Renvoie la seconde, sous forme d'entier allant de 0 à 59."
 
 #: ../Doc/c-api/datetime.rst:170 ../Doc/c-api/datetime.rst:194
 msgid "Return the microsecond, as an int from 0 through 999999."
-msgstr ""
+msgstr "Renvoie la microseconde, sous forme d'entier allant de 0 à 999999."
 
 #: ../Doc/c-api/datetime.rst:173
 msgid ""
@@ -194,6 +248,9 @@ msgid ""
 "instance of :c:data:`PyDateTime_Time`, including subclasses. The argument "
 "must not be *NULL*, and the type is not checked:"
 msgstr ""
+"Macros pour extraire les champs des objets *time*. L'argument doit être une "
+"instance de :c:data:`PyDateTime_Time` ou une sous-classe de celle-ci. "
+"L'argument ne doit pas être *NULL*, et le type n'est pas vérifié :"
 
 #: ../Doc/c-api/datetime.rst:197
 msgid ""
@@ -201,31 +258,42 @@ msgid ""
 "instance of :c:data:`PyDateTime_Delta`, including subclasses. The argument "
 "must not be *NULL*, and the type is not checked:"
 msgstr ""
+"Macros pour extraire les champs des objets *time delta*. L'argument doit être "
+"une instance de :c:data:`PyDateTime_Delta` ou une sous-classe de celle-ci. "
+"L'argument ne doit pas être *NULL*, et le type n'est pas vérifié :"
 
 #: ../Doc/c-api/datetime.rst:203
 msgid "Return the number of days, as an int from -999999999 to 999999999."
 msgstr ""
+"Renvoie le nombre de jours, sous forme d'entier allant de -999999999 à "
+"999999999."
 
 #: ../Doc/c-api/datetime.rst:210
 msgid "Return the number of seconds, as an int from 0 through 86399."
-msgstr ""
+msgstr "Renvoie le nombre de secondes sous forme d'entier allant de 0 à 86399."
 
 #: ../Doc/c-api/datetime.rst:217
 msgid "Return the number of microseconds, as an int from 0 through 999999."
 msgstr ""
+"Renvoie le nombre de microsecondes, sous forme d'entier allant de 0 à 999999."
 
 #: ../Doc/c-api/datetime.rst:222
 msgid "Macros for the convenience of modules implementing the DB API:"
-msgstr ""
+msgstr "Macros de confort pour les modules implémentant l'API DB :"
 
 #: ../Doc/c-api/datetime.rst:226
 msgid ""
 "Create and return a new :class:`datetime.datetime` object given an argument "
 "tuple suitable for passing to :meth:`datetime.datetime.fromtimestamp()`."
 msgstr ""
+"Crée et renvoie un nouvel objet :class:`datetime.datetime` à partir "
+"d'un n-uplet qui peut être passé à :meth:`datetime.datetime."
+"fromtimestamp()`."
 
 #: ../Doc/c-api/datetime.rst:232
 msgid ""
 "Create and return a new :class:`datetime.date` object given an argument "
 "tuple suitable for passing to :meth:`datetime.date.fromtimestamp()`."
 msgstr ""
+"Crée et renvoie un nouvel objet :class:`datetime.date` à partir d'un "
+"n-uplet qui peut être passé à :meth:`datetime.date.fromtimestamp()`."
diff --git a/howto/functional.po b/howto/functional.po
index 245745535..11f5c2762 100644
--- a/howto/functional.po
+++ b/howto/functional.po
@@ -6,17 +6,18 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2018-12-21 09:48+0100\n"
-"PO-Revision-Date: 2018-02-15 00:38+0100\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"PO-Revision-Date: 2019-05-10 19:36+0200\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\n"
 "Language: fr\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+"Last-Translator: Louis Portay <lportay@student.42.fr>\n"
+"X-Generator: Poedit 2.2.1\n"
 
 #: ../Doc/howto/functional.rst:3
 msgid "Functional Programming HOWTO"
-msgstr ""
+msgstr "Programmation Fonctionelle INTRODUCTION"
 
 #: ../Doc/howto/functional.rst:0
 msgid "Author"
@@ -24,7 +25,7 @@ msgstr "Auteur"
 
 #: ../Doc/howto/functional.rst:5
 msgid "A. M. Kuchling"
-msgstr ""
+msgstr "A. M. Kuchling"
 
 #: ../Doc/howto/functional.rst:0
 msgid "Release"
@@ -32,7 +33,7 @@ msgstr "Version"
 
 #: ../Doc/howto/functional.rst:6
 msgid "0.32"
-msgstr ""
+msgstr "0.32"
 
 #: ../Doc/howto/functional.rst:8
 msgid ""
@@ -42,6 +43,12 @@ msgid ""
 "term:`iterator`\\s and :term:`generator`\\s and relevant library modules "
 "such as :mod:`itertools` and :mod:`functools`."
 msgstr ""
+"Dans ce document, nous étudierons les fonctionnalités de Python adaptées "
+"pour programmer dans un style fonctionnel. Après une introduction aux "
+"concepts de la programmation fonctionnelle, nous verrons certaines "
+"fonctionnalités du langage comme  les :term:`itérateurs`, les :term:"
+"`générateurs` et les librairies pertinentes tel que :mod:`itertools` et :mod:"
+"`functools`."
 
 #: ../Doc/howto/functional.rst:16
 msgid "Introduction"
@@ -53,11 +60,16 @@ msgid ""
 "just interested in learning about Python language features, skip to the next "
 "section on :ref:`functional-howto-iterators`."
 msgstr ""
+"Cette section explique le concept de base de la programmation fonctionnelle; "
+"Si vous êtes intéressé par apprendre des fonctionnalités de Python, passez à "
+"la section suivante sur les :ref:`functional-howto-iterators`."
 
 #: ../Doc/howto/functional.rst:22
 msgid ""
 "Programming languages support decomposing problems in several different ways:"
 msgstr ""
+"Les langages de programmation peuvent décomposer les problèmes de plusieurs "
+"façons différentes:"
 
 #: ../Doc/howto/functional.rst:24
 msgid ""
@@ -65,6 +77,10 @@ msgid ""
 "instructions that tell the computer what to do with the program's input.  C, "
 "Pascal, and even Unix shells are procedural languages."
 msgstr ""
+"La plupart des langages de programmation sont dits **procéduraux**: Les "
+"programmes sont des listes d'instructions qui disent à l'ordinateur quoi "
+"faire avec l'entrée reçue. C, Pascal et même les shells Unix sont des "
+"langages procéduraux."
 
 #: ../Doc/howto/functional.rst:28
 msgid ""
@@ -75,6 +91,13 @@ msgid ""
 "to retrieve, and the SQL engine decides whether to scan tables or use "
 "indexes, which subclauses should be performed first, etc."
 msgstr ""
+"Dans les langages dits **déclaratifs**, on écrit une spécification qui "
+"décrit le problème à résoudre et l'implémentation du langage choisit comment "
+"effectuer le calcul le plus efficace pour arriver à la solution. SQL est le "
+"langage déclaratif avec lequel vous êtes probablement le plus familier; une "
+"requête SQL décrit l'ensemble de données que vous voulez récupérer et le "
+"moteur SQL décide soit de scanner les tables soit d'utiliser les indices, "
+"détermine quel sous-paragraphe doit être exécuté en premier, etc..."
 
 #: ../Doc/howto/functional.rst:35
 msgid ""
@@ -84,6 +107,12 @@ msgid ""
 "and Python are languages that support object-oriented programming, but don't "
 "force the use of object-oriented features."
 msgstr ""
+"Les programmes écrits avec des langages dits **orientés objets** manipulent "
+"des collections d'objets. Ces objets conservent un état interne et ont des "
+"méthodes qui accèdent ou modifient cet état interne d'une façon ou d'une "
+"autre. Smalltalk et Java sont des langages orientés objets. C++ et Python "
+"sont des langages qui implémentent le paradigme objet mais ne force pas son "
+"utilisation."
 
 #: ../Doc/howto/functional.rst:41
 msgid ""
@@ -93,6 +122,12 @@ msgid ""
 "known functional languages include the ML family (Standard ML, OCaml, and "
 "other variants) and Haskell."
 msgstr ""
+"La programmation **fonctionnelle** décompose un probléme en un ensemble de "
+"fonctions. Idéalement, des fonctions qui ne prennent que des entrées et des "
+"sorties et qui ne conservent aucun état interne qui affecte la sortie "
+"produite pour une entrée donnée. Parmi les langages fonctionnels connus on "
+"peut citer la famille ML (Standard ML, OCaml ainsi que d'autres variantes) "
+"et Haskell."
 
 #: ../Doc/howto/functional.rst:47
 msgid ""
@@ -106,6 +141,16 @@ msgid ""
 "GUI might be object-oriented while the processing logic is procedural or "
 "functional, for example."
 msgstr ""
+"Les concepteurs de certains langages choisissent de mettre l'accent sur une "
+"approche particulière de la programmation. Cela rend souvent l'écriture de "
+"programmes avec une approche différente difficile. D'autres langages sont "
+"multi-paradigmes, cela veut dire qu'ils proposent différentes approches. "
+"Lisp, C++ et Python sont multi-paradigmes; vous pouvez écrire des programmes "
+"ou des librairies dans un style majoritairement procédural, orienté objet ou "
+"bien fonctionnel dans tous ces langages.  Dans un programme d'envergure, "
+"différentes portions peuvent être écrites en utilisant différentes "
+"approches; l'interface graphique peut être orienté objet tandis que la "
+"logique du programme peut être procédural ou fonctionnel par exemple."
 
 #: ../Doc/howto/functional.rst:58
 msgid ""
@@ -117,6 +162,15 @@ msgid ""
 "side effects means not using data structures that get updated as a program "
 "runs; every function's output must only depend on its input."
 msgstr ""
+"Dans un programme fonctionnel, l'entrée parcourt un ensemble de fonctions. "
+"Chaque fonction agit sur cette entrée et génère une sortie. Le style "
+"fonctionnel dissuade l'emploi de fonctions avec des effets de bord qui "
+"modifient un état interne ou effectue d'autres changements qui ne sont pas "
+"visibles dans la valeur de retour de la fonction.  Les fonctions qui n'ont "
+"aucun effet de bord sont dites **pures** . Eviter les effets de bord "
+"implique de ne pas utiliser de structure de données qui sera modifiée "
+"lorsque le programme est exécuté; chaque retour de fonction doit dépendre "
+"uniquement de ses paramètres."
 
 #: ../Doc/howto/functional.rst:66
 msgid ""
@@ -128,6 +182,14 @@ msgid ""
 "called for their side effects of sending some text to the screen or pausing "
 "execution for a second."
 msgstr ""
+"Certains langages sont très stricts sur la pureté des fonctions et n'ont pas "
+"d'assignations comme ``a=3`` ou ``c = a + b``, mais il est difficile de se "
+"débarasser de tous les effets de bord. Imprimer quelque chose sur l'écran ou "
+"écrire sur le disque sont des effets de bord par exemple. Par exemple, en "
+"Python, un appel à la fonction  :func:`print` ou à :func:`time.sleep` ne "
+"renvoie aucune valeur utile; elles sont seulement appelées pour leurs effet "
+"de bord d'envoyer du texte à l'écran ou de mettre en pause l'exécution pour "
+"une seconde."
 
 #: ../Doc/howto/functional.rst:74
 msgid ""
@@ -138,6 +200,13 @@ msgid ""
 "assignments to local variables, but won't modify global variables or have "
 "other side effects."
 msgstr ""
+"Les programmes écrits dans un style fonctionnel avec Python ne suivent pas "
+"la voie extrême d'éviter toute I/O ou de n'effectuer aucune assignation; Ils "
+"affichent plutôt une interface en apparence fonctionnelle avec des "
+"mécanismes non-fonctionnelles en interne. Par exemple, l'implémentation "
+"d'une fonction utilisera toujours des assignations à des variables locales, "
+"mais ne modifiera pas de variables globales et n'aura pas d'autres effets de "
+"bord."
 
 #: ../Doc/howto/functional.rst:80
 msgid ""
@@ -150,6 +219,16 @@ msgid ""
 "approaches by writing functions that take and return instances representing "
 "objects in your application (e-mail messages, transactions, etc.)."
 msgstr ""
+"La programmation fonctionnelle peut être considéré comme l'opposé de la "
+"programmation orienté objet. Les objets sont des petites capsules contenant "
+"un état interne accompagné d'un ensemble de méthodes qui permettent de "
+"modifier cet état, et les programmes consistent à effectuer la bonne "
+"combinaison de changements d'états. La programmation fonctionelle souhaite "
+"éviter autant que possible les changements d'état et fonctionne avec les "
+"données passant d'une fonction à l'autre.  Python vous laisse combiner les "
+"deux approches en écrivant des fonctions qui prennent en paramètre et "
+"renvoient des instances modélisant des objets dans votre application (e-"
+"mails, transactions, etc.)."
 
 #: ../Doc/howto/functional.rst:89
 msgid ""
@@ -157,32 +236,37 @@ msgid ""
 "you avoid objects and side effects?  There are theoretical and practical "
 "advantages to the functional style:"
 msgstr ""
+"Le paradigme fonctionnel peut sembler être une contrainte étrange sous "
+"laquelle travailler. Pourquoi devoir éviter les objets et les effets de "
+"bord ? Il y a des avantages théoriques et pratiques au style fonctionnel:"
 
 #: ../Doc/howto/functional.rst:93
 msgid "Formal provability."
-msgstr ""
+msgstr "Prouvabilité formelle."
 
 #: ../Doc/howto/functional.rst:94
 msgid "Modularity."
-msgstr ""
+msgstr "Modularité."
 
 #: ../Doc/howto/functional.rst:95
 msgid "Composability."
-msgstr ""
+msgstr "Composabilité."
 
 #: ../Doc/howto/functional.rst:96
 msgid "Ease of debugging and testing."
-msgstr ""
+msgstr "Simplicité à débugger et à tester."
 
 #: ../Doc/howto/functional.rst:100
 msgid "Formal provability"
-msgstr ""
+msgstr "Prouvabilité formelle"
 
 #: ../Doc/howto/functional.rst:102
 msgid ""
 "A theoretical benefit is that it's easier to construct a mathematical proof "
 "that a functional program is correct."
 msgstr ""
+"Un bénéfice théorique de la programmation fonctionnelle est la simplicité de "
+"prouver mathématiquement qu'un programme est correct."
 
 #: ../Doc/howto/functional.rst:105
 msgid ""
@@ -193,6 +277,12 @@ msgid ""
 "looks right; the goal is instead a rigorous proof that a program produces "
 "the right result for all possible inputs."
 msgstr ""
+"Les chercheurs ont longtemps été intéressés par des moyens de prouver "
+"mathématiquement que des programmes sont corrects. Cela est différent de "
+"tester un programme sur de nombreuses entrées et de conclure que son "
+"résultat est souvent le bon, ou de lire le code source et de conclure que le "
+"code semble bon; le but ici est plutôt de produire une preuve rigoureuse "
+"qu'un programme produit le bon résultat pour toutes les entrées possibles."
 
 #: ../Doc/howto/functional.rst:112
 msgid ""
@@ -204,6 +294,13 @@ msgid ""
 "This continues until you reach the end of the program, at which point the "
 "invariants should match the desired conditions on the program's output."
 msgstr ""
+"La technique utilisée pour prouver l'exactitude des programmes consiste à "
+"établir des **invariants**, ce sont certaines propriétés des paramètres et "
+"des variables du programme qui sont toujours vraies. Pour chaque ligne de "
+"code, on montre que si les invariants X et Y sont vrais **avant** d'exécuter "
+"la ligne,  les invariants légèrements différents X' et Y' sont vrais après "
+"que la ligne soit exécutée. Cela continue jusqu'à la fin du programme, où "
+"les invariants doivent correspondre à la sortie attendue du programme."
 
 #: ../Doc/howto/functional.rst:120
 msgid ""
@@ -212,6 +309,11 @@ msgid ""
 "invariants that were true before the assignment without producing any new "
 "invariants that can be propagated onward."
 msgstr ""
+"Le rejet des assignations en programmation fonctionnelle vient du fait que "
+"les assignations sont difficiles à gérer avec cette technique; Les "
+"assignations peuvent induire en erreur des invariants qui étaient vrais "
+"avant l'assignation sans produire de nouveaux invariants qui peuvent être "
+"propagés dans la suite du programme."
 
 #: ../Doc/howto/functional.rst:125
 msgid ""
@@ -224,10 +326,20 @@ msgid ""
 "the question of verifying the proof; maybe there's an error in it, and you "
 "wrongly believe you've proved the program correct."
 msgstr ""
+"Malheureusement, prouver l'exactitude des programmes est globalement "
+"impraticable et peu pertinent pour les programmes écrits en Python. Même des "
+"programmes triviaux nécéssitent des preuves longues de plusieurs pages; "
+"Prouver l'exactitude d'un programme modérément compliqué serait démesuré, et "
+"peu voire aucun des programmes que vous utilisez quotidiennement "
+"(L'interpréteur Pyhton, votre parser XML, votre navigateur web...) pourrait "
+"être prouvé comme étant exacts. Même si vous écriviez ou génériez une telle "
+"preuve, il y aurait ensuite la question de vérifier la preuve elle-même; "
+"peut-être contient-elle une erreur alors que vous pensiez avoir prouvé "
+"l'exactitude du programme."
 
 #: ../Doc/howto/functional.rst:136
 msgid "Modularity"
-msgstr ""
+msgstr "Modularité"
 
 #: ../Doc/howto/functional.rst:138
 msgid ""
@@ -237,14 +349,21 @@ msgid ""
 "thing than a large function that performs a complicated transformation.  "
 "Small functions are also easier to read and to check for errors."
 msgstr ""
+"La programmation fonctionnelle a comme bénéfice plus pratique de vous "
+"obliger à découper votre problème en plus petits morceaux. Les programmes "
+"sont par conséquent plus modulaires. Il est plus facile de conceptualiser et "
+"d'écrire une petite fonction qui fait une seule chose plutôt qu'une longue "
+"fonction qui effectue une transformation compliquée. Les fonctions courtes "
+"sont aussi plus faciles à lire et à corriger."
 
 #: ../Doc/howto/functional.rst:146
 msgid "Ease of debugging and testing"
-msgstr ""
+msgstr "Facilité pour debugger et tester"
 
 #: ../Doc/howto/functional.rst:148
 msgid "Testing and debugging a functional-style program is easier."
 msgstr ""
+"La programmation fonctionnelle simplifie les processus de test et de debug."
 
 #: ../Doc/howto/functional.rst:150
 msgid ""
@@ -254,6 +373,11 @@ msgid ""
 "intermediate inputs and outputs to quickly isolate the function that's "
 "responsible for a bug."
 msgstr ""
+"Les fonctions sont généralement courtes et clairement spécifiées, ce qui "
+"simplifie le debug. Quand un programme ne fonctionne pas, chaque fonction "
+"est un point d'interface où l'on peut vérifier si la donnée produite en "
+"sortie est correcte. On peut aussi voir les entrées et les sorties "
+"intermédiaires pour isoler rapidement la fonction responsable d'un bug."
 
 #: ../Doc/howto/functional.rst:155
 msgid ""
@@ -262,10 +386,14 @@ msgid ""
 "before running a test; instead you only have to synthesize the right input "
 "and then check that the output matches expectations."
 msgstr ""
+"Les tests sont simplifiés car chaque fonction est potentiellement sujette à "
+"un test unitaire. Les fonctions ne dépendent pas de l'état d'un système qui "
+"doit être répliqué avant d'exécuter un test; on doit plutôt synthétiser les "
+"entrées correctes et vérifier qu'elles correspondent aux sorties attendues."
 
 #: ../Doc/howto/functional.rst:162
 msgid "Composability"
-msgstr ""
+msgstr "Composabilité"
 
 #: ../Doc/howto/functional.rst:164
 msgid ""
@@ -277,6 +405,14 @@ msgid ""
 "that takes a filename and returns its contents, can be applied to many "
 "different situations."
 msgstr ""
+"En travaillant sur un programme rédigé de façon fonctionnelle, vous écrirez "
+"beaucoup de fonctions avec des entrées et des sorties variables. Certaines "
+"de ces fonctions seront inévitablement spécialisées pour une certaine "
+"application, mais d'autres seront utiles dans de futurs programmes. Par "
+"exemple, une fonction qui prend le chemin d'un dossier et renvoie tous les "
+"fichiers XML dans ce dossier, ou une fonction qui prend un fichier en "
+"paramètre et renvoie son contenu, peut être utilisé dans de nombreux cas de "
+"figure."
 
 #: ../Doc/howto/functional.rst:171
 msgid ""
@@ -284,6 +420,10 @@ msgid ""
 "assemble new programs by arranging existing functions in a new configuration "
 "and writing a few functions specialized for the current task."
 msgstr ""
+"Avec le temps, vous créerez une librairie personnelle de fonctions utiles. "
+"Vous assemblerez de nouveaux programmes en arrangeant vos fonctions d'une "
+"nouvelle façon et en en écrivant d'autres plus spécialisées dans la tâche "
+"actuelle."
 
 #: ../Doc/howto/functional.rst:179
 msgid "Iterators"
@@ -294,6 +434,9 @@ msgid ""
 "I'll start by looking at a Python language feature that's an important "
 "foundation for writing functional-style programs: iterators."
 msgstr ""
+"Je vais commencer par montrer une fonctionnalité de Python qui est un point "
+"important pour écrire des programmes dans un style fonctionnel: Les "
+"itérateurs."
 
 #: ../Doc/howto/functional.rst:184
 msgid ""
@@ -305,6 +448,14 @@ msgid ""
 "exception. Iterators don't have to be finite, though; it's perfectly "
 "reasonable to write an iterator that produces an infinite stream of data."
 msgstr ""
+"Un itérateur est un objet qui représente un flux de données: cet objet "
+"renvoie les données, un élément à la fois. Un itérateur Python doit "
+"implémenter une méthode appelée :meth:`~iterator.__next__` qui ne prend "
+"aucun argument et renvoie toujours l'élément suivant de ce flot. S'il n'y a "
+"plus d'éléments dans le flot, :meth:~iterator.__next__` doit lever "
+"l'excpetion :exc:`StopIteration`. Les itérateurs ne doivent pas forcément "
+"être finis; Il est parfaitement acceptable d'écrire un itérateur qui produit "
+"un flot de données ininterrompu."
 
 #: ../Doc/howto/functional.rst:192
 msgid ""
@@ -315,10 +466,16 @@ msgid ""
 "lists and dictionaries.  An object is called :term:`iterable` if you can get "
 "an iterator for it."
 msgstr ""
+"La fonction native :func:`iter` prend un objet arbitraire et essaye de "
+"renvoyer un itérateur qui renverra les éléments de l'objet et lève "
+"l'exception :exc:`TypeError` si l'on ne peut pas itérer sur l'objet. "
+"Plusieurs types natifs de Python prennent en charge l'itération. les plus "
+"communs étant les listes et les dictionnaires. Un objet est dit :term:"
+"`iterable` si l'on peut en obtenir un itérateur."
 
 #: ../Doc/howto/functional.rst:199
 msgid "You can experiment with the iteration interface manually:"
-msgstr ""
+msgstr "Vous pouvez expérimenter avec les itérateurs manuellement:"
 
 #: ../Doc/howto/functional.rst:217
 msgid ""
@@ -327,18 +484,26 @@ msgid ""
 "Y``, Y must be an iterator or some object for which :func:`iter` can create "
 "an iterator.  These two statements are equivalent::"
 msgstr ""
+"Python s'attend à trouver des objets itérables dans des contextes variés, le "
+"plus important étant la boucle :keyword:`for`.Dans la boucle ``for X in Y``, "
+"Y doit être un itérateur ou un objet pour lequel :func:`iter` doit pouvoir "
+"créer un itérateur. Ces deux déclarations sont équivalentes::"
 
 #: ../Doc/howto/functional.rst:229
 msgid ""
 "Iterators can be materialized as lists or tuples by using the :func:`list` "
 "or :func:`tuple` constructor functions:"
 msgstr ""
+"Les itérateurs peuvent être matérialisés par des listes ou des n-uplet en "
+"utilisant les constructeurs :func:`list` ou :func:`tuple`:"
 
 #: ../Doc/howto/functional.rst:238
 msgid ""
 "Sequence unpacking also supports iterators: if you know an iterator will "
 "return N elements, you can unpack them into an N-tuple:"
 msgstr ""
+"La déconstruction prend aussi en charge les itérateurs: Si vous savez qu'un "
+"itérateur renvoie N éléments, vous pouvez les dépaqueter dans un N-uplet:"
 
 #: ../Doc/howto/functional.rst:247
 msgid ""
@@ -350,6 +515,14 @@ msgid ""
 "func:`min` will never return, and if the element X never appears in the "
 "stream, the ``\"in\"`` and ``\"not in\"`` operators won't return either."
 msgstr ""
+"Les fonctions natives tel que :func:`max` et :func:`min` peuvent prendre un "
+"seul itérateur en argument et renvoyer l'élément le plus important ou le "
+"plus petit. Les opérateurs ``\"in\"`` et ``\"not in\"`` prennent aussi en "
+"charge les itérateurs: ``X in iterator`` est vrai si X est trouvé dans le "
+"flux renvoyé par l'itérateur. Vous rencontrerez des problèmes évidents si "
+"l'itérateur est infini; :func:`max`, :func:`min` ne renverront jamais, et si "
+"l'élément X n'apparaît jamais dans le flot, les opérateurs ``\"in\"`` et ``"
+"\"not in\"`` ne renverront jamais non plus."
 
 #: ../Doc/howto/functional.rst:255
 msgid ""
@@ -361,10 +534,17 @@ msgid ""
 "need to do something different with the same stream, you'll have to create a "
 "new iterator."
 msgstr ""
+"Veuillez noter qu'un itérateur ne peut qu'avancer; il n'y a aucun moyen "
+"d'obtenir l'élément précédent, de réinitialiser l'itérateur ou d'en faire "
+"une copie. Certains itérateurs peuvent optionnellement fournir ces capacités "
+"supplémentaires, mais le protocole des itérateurs ne spécifie que la "
+"méthode :meth:`~iterator.__next__`. Les fonctions peuvent donc consommer "
+"entièrement la sortie de l'itérateur; et si vous devez faire quelque chose "
+"d'autre avec ce même flux, vous devrez créer un nouvel itérateur."
 
 #: ../Doc/howto/functional.rst:265
 msgid "Data Types That Support Iterators"
-msgstr ""
+msgstr "Les Types de Données qui prennent en charge les Itérateurs"
 
 #: ../Doc/howto/functional.rst:267
 msgid ""
@@ -372,12 +552,17 @@ msgid ""
 "Python sequence type, such as strings, will automatically support creation "
 "of an iterator."
 msgstr ""
+"Nous avons déjà vu comment les listes et les n-uplet gèrent les itérateurs. "
+"En réalité, n'importe quel type séquentiel Python; tel que les chaînes de "
+"caractère, prennent automatiquement en charge la création d'itérateurs."
 
 #: ../Doc/howto/functional.rst:271
 msgid ""
 "Calling :func:`iter` on a dictionary returns an iterator that will loop over "
 "the dictionary's keys::"
 msgstr ""
+"Appeler :func:`iter` sur un dictionnaire renvoie un itérateur qui boucle sur "
+"les clés dudit dictionnaire::"
 
 #: ../Doc/howto/functional.rst:291
 msgid ""
@@ -385,6 +570,10 @@ msgid ""
 "to be the same as the insertion order. In earlier versions, the behaviour "
 "was unspecified and could vary between implementations."
 msgstr ""
+"Notez qu'à partir de Pyhton 3.7, l'ordre d'itération sur un dictionnaire est "
+"garanti d'être le même que celui d'insertion. Sur les versions précédentes, "
+"le comportement n'était pas défini et pouvait varier selon les "
+"implémentations."
 
 #: ../Doc/howto/functional.rst:295
 msgid ""
@@ -393,12 +582,19 @@ msgid ""
 "iterate over values or key/value pairs, you can explicitly call the :meth:"
 "`~dict.values` or :meth:`~dict.items` methods to get an appropriate iterator."
 msgstr ""
+"Appeler :func:`iter` sur un dictionnaire boucle toujours sur les clés, mais "
+"les dictionnaires disposent d'autres méthodes qui renvoient d'autres "
+"itérateurs. Si vous voulez boucler sur les valeurs ou sur les paires clé/"
+"valeur, vous pouvez appeler explicitement les méthodes :meth:`~dict.values` "
+"ou :meth:`dict.items` pour obtenir l'itérateur approprié."
 
 #: ../Doc/howto/functional.rst:301
 msgid ""
 "The :func:`dict` constructor can accept an iterator that returns a finite "
 "stream of ``(key, value)`` tuples:"
 msgstr ""
+"Le constructeur :func:`dict` peut accepter un itérateur qui renvoie un flux "
+"fini de n-uplet ``(clé, valeur)`` :"
 
 #: ../Doc/howto/functional.rst:308
 msgid ""
@@ -406,16 +602,22 @@ msgid ""
 "method until there are no more lines in the file.  This means you can read "
 "each line of a file like this::"
 msgstr ""
+"Les fichiers supportent aussi l'itération en appelant la méthode :meth:`~io."
+"TextIOBase.readline` jusqu'à ce qu'il n'y ait plus de lignes dans le "
+"fichier. Cela signifie que vous pouvez lire chaque ligne d'un fichier comme "
+"ceci::"
 
 #: ../Doc/howto/functional.rst:316
 msgid ""
 "Sets can take their contents from an iterable and let you iterate over the "
 "set's elements::"
 msgstr ""
+"Les ensembles peuvent aussi prendre leur contenu depuis un itérable et vous "
+"laisser itérer sur leurs éléments::"
 
 #: ../Doc/howto/functional.rst:326
 msgid "Generator expressions and list comprehensions"
-msgstr ""
+msgstr "Expressions génératrices et compréhensions de liste"
 
 #: ../Doc/howto/functional.rst:328
 msgid ""
@@ -425,6 +627,11 @@ msgid ""
 "strip off trailing whitespace from each line or extract all the strings "
 "containing a given substring."
 msgstr ""
+"Deux opérations fréquentes sur la sortie d'un itérateur sont 1) d'effectuer "
+"une opération sur chaque élément 2) de séléctionner un sous-ensemble "
+"d'éléments qui remplissent certaines conditions. Par exemple, avec une liste "
+"de chaînes données, on peut vouloir enlever les espaces en fin de ligne ou "
+"ne garder que les chaînes contenant une sous-chaîne donnée."
 
 #: ../Doc/howto/functional.rst:334
 msgid ""
@@ -433,11 +640,18 @@ msgid ""
 "functional programming language Haskell (https://www.haskell.org/).  You can "
 "strip all the whitespace from a stream of strings with the following code::"
 msgstr ""
+"Les compréhensions de liste et les expressions génératrices (abrégés en "
+"\"listcomps\" et \"genexps\") sont une notation concise pour de telles "
+"opérations, elles ont été empruntées au langage fonctionnel Haskell (https://"
+"www.haskell.org/). On peut supprimer tous les espaces blancs d'un flux de "
+"chaînes avec le code suivant::"
 
 #: ../Doc/howto/functional.rst:347
 msgid ""
 "You can select only certain elements by adding an ``\"if\"`` condition::"
 msgstr ""
+"On peut séléctionner seulement certains éléments en ajoutant une condition ``"
+"\"if\"``::"
 
 #: ../Doc/howto/functional.rst:352
 msgid ""
@@ -449,6 +663,14 @@ msgid ""
 "infinite stream or a very large amount of data.  Generator expressions are "
 "preferable in these situations."
 msgstr ""
+"Une compréhension de liste nous renvoie une liste Python; ``stripped_list`` "
+"est une liste contenant les lignes renvoyées et non un itérateur. Les "
+"expressions génératrices renvoient un itérateur qui calculent les valeurs si "
+"nécéssaires, sans avoir besoin de toutes les matérialiser à la fois. Cela "
+"signifie que les compréhensions de liste n'ont pas d'intérêt si l'on "
+"travaille avec des itérateurs renvoyant un flux infini ou une importante "
+"quantité de données. Les expressions génératrices sont alors préférables "
+"dans ces situations."
 
 #: ../Doc/howto/functional.rst:359
 msgid ""
@@ -456,12 +678,17 @@ msgid ""
 "comprehensions are surrounded by square brackets (\"[]\").  Generator "
 "expressions have the form::"
 msgstr ""
+"Les expressions génératrices sont contenues dans des parenthèses (\"()\") et "
+"les compréhensions de liste dans des crochets (\"[]\"). Les expressions "
+"génératrices ont la forme::"
 
 #: ../Doc/howto/functional.rst:372
 msgid ""
 "Again, for a list comprehension only the outside brackets are different "
 "(square brackets instead of parentheses)."
 msgstr ""
+"Ici encore, pour une compréhension de liste, seuls les crochets extérieurs "
+"sont différents (crochets au lieu de parenthèses)"
 
 #: ../Doc/howto/functional.rst:375
 msgid ""
@@ -470,6 +697,10 @@ msgid ""
 "``expression`` is only evaluated and added to the result when ``condition`` "
 "is true."
 msgstr ""
+"Les éléments de la sortie générée seront les valeurs successives de "
+"l'``expression``. Les clauses de la condition ``if``  sont optionnelles; si "
+"elle est présente, l'``expresssion`` est seulement évaluée et ajoutée au "
+"résultat lorsque la condition est vérifiée."
 
 #: ../Doc/howto/functional.rst:379
 msgid ""
@@ -477,6 +708,10 @@ msgid ""
 "parentheses signalling a function call also count.  If you want to create an "
 "iterator that will be immediately passed to a function you can write::"
 msgstr ""
+"Les expressions génératrices doivent toujours être écrites à l'intérieur de "
+"parenthèses, mais les parenthèses d'un appel à fonction peuvent aussi "
+"compter. Si l'on veut créer un itérateur qui sera immédiatement passé à une "
+"fonction, on peut écrire::"
 
 #: ../Doc/howto/functional.rst:385
 msgid ""
@@ -487,12 +722,20 @@ msgid ""
 "looped over for each resulting pair of elements from ``sequence1`` and "
 "``sequence2``."
 msgstr ""
+"Les clauses ``for...in`` contiennent les séquences qui seront itérées. Ces "
+"séquences ne doivent pas forcément être de la même longueur, car elles sont "
+"parcourues de gauche à droite; **non** en parallèle. Pour chaque élément "
+"dans ``sequence1``, ``sequence2`` est reparcouru depuis le début. "
+"``sequence3`` est alors itéré pour chaque paire résultant des éléments "
+"combinés de ``sequence1`` et de ``sequence2``."
 
 #: ../Doc/howto/functional.rst:391
 msgid ""
 "To put it another way, a list comprehension or generator expression is "
 "equivalent to the following Python code::"
 msgstr ""
+"Pour le dire d'une autre façon, une compréhension de liste ou une expression "
+"génératrice est équivalente au code Python suivant::"
 
 #: ../Doc/howto/functional.rst:408
 msgid ""
@@ -501,6 +744,10 @@ msgid ""
 "the lengths of all the sequences.  If you have two lists of length 3, the "
 "output list is 9 elements long:"
 msgstr ""
+"Cela signifie que pour plusieurs ``for...in`` conditions sans ``if``, la "
+"longueur de la sortie correspondra au produit des longeurs de toutes les "
+"séquences. Si l'on a deux listes de longueur 3 alors la sortie comportera 9 "
+"éléments:"
 
 #: ../Doc/howto/functional.rst:420
 msgid ""
@@ -508,6 +755,10 @@ msgid ""
 "is creating a tuple, it must be surrounded with parentheses.  The first list "
 "comprehension below is a syntax error, while the second one is correct::"
 msgstr ""
+"Pour éviter d'introduire une ambiguïté dans la grammaire de Python, si "
+"l'``expression`` crée un n-uplet, il doit être entouré de parenthèses. La "
+"première compréhension de liste ci-dessous comporte une erreur de syntaxe "
+"alors que la seconde est correcte::"
 
 #: ../Doc/howto/functional.rst:431
 msgid "Generators"
@@ -519,6 +770,10 @@ msgid ""
 "writing iterators.  Regular functions compute a value and return it, but "
 "generators return an iterator that returns a stream of values."
 msgstr ""
+"Les générateurs sont un ensemble particulier de fonctions qui simplifie "
+"l'écriture d'itérateurs. Les fonctions usuelles calculent une valeur et la "
+"renvoient, tandis que les générateurs renvoient un itérateur qui lui-même "
+"renvoie un flux de données."
 
 #: ../Doc/howto/functional.rst:437
 msgid ""
@@ -532,10 +787,20 @@ msgid ""
 "function where it left off?  This is what generators provide; they can be "
 "thought of as resumable functions."
 msgstr ""
+"Vous êtes sans doute familier sur la façon d'appeler des fonctions en Python "
+"ou en C. Lorsqu'on appelle une fonction, elle génère un espace privé où ses "
+"variables locales sont créées. Au moment où la fonction atteint un "
+"``return``, les variables locales sont détruites et la valeur est retournée "
+"à la fonction appelante. Un appel ultérieur à cette même fonction crée un "
+"nouvel espace privé et un nouvel ensemble de variables locales. Mais si les "
+"variables locales n'étaient pas détruites à la fin de cette fonction ? Si "
+"l'exécution de cette fonction reprenait à l'endroit où elle était restée ? "
+"C'est le rôle que les générateurs remplissent; On peut les imaginer comme "
+"des fonctions interruptibles."
 
 #: ../Doc/howto/functional.rst:446
 msgid "Here's the simplest example of a generator function:"
-msgstr ""
+msgstr "Voici le plus simple exemple d'un générateur:"
 
 #: ../Doc/howto/functional.rst:452
 msgid ""
@@ -543,6 +808,9 @@ msgid ""
 "this is detected by Python's :term:`bytecode` compiler which compiles the "
 "function specially as a result."
 msgstr ""
+"Chaque fonction contenant le mot-clé :keyword:`yield` est un générateur; "
+"c'est détecté par le compilateur de :term:`bytecode` Python qui va en "
+"conséquence compiler la fonction différement."
 
 #: ../Doc/howto/functional.rst:456
 msgid ""
@@ -555,16 +823,25 @@ msgid ""
 "preserved.  On the next call to the generator's :meth:`~generator.__next__` "
 "method, the function will resume executing."
 msgstr ""
+"L'appel d'un générateur ne renvoie pas une simple valeur; il renvoie plutôt "
+"un objet qui suporte le protocole des itérateurs. Lors de l'exécution de "
+"l'expression ``yield``, le générateur retourne ``i``, qui est similaire à un "
+"``return``. La grande différence entre un ``yield`` et un ``return`` réside "
+"dans le fait qu'un appel à `` yield`` préserve l'état du générateur et les "
+"variables locales sont conservées. Au prochain appel de la méthode :meth:"
+"`~generator.__next__` du générateur, la fonction reprendra son exécution."
 
 #: ../Doc/howto/functional.rst:465
 msgid "Here's a sample usage of the ``generate_ints()`` generator:"
-msgstr ""
+msgstr "Voici un exemple d'utilisation pour le générateur ``generate_ints()``:"
 
 #: ../Doc/howto/functional.rst:482
 msgid ""
 "You could equally write ``for i in generate_ints(5)``, or ``a, b, c = "
 "generate_ints(3)``."
 msgstr ""
+"On peut également écrire ``for i in generate_ints(5)``, ou ``a,b,c = "
+"generate_ints(3)``."
 
 #: ../Doc/howto/functional.rst:485
 msgid ""
@@ -573,6 +850,11 @@ msgid ""
 "method.  Once this happens, or the bottom of the function is reached, the "
 "procession of values ends and the generator cannot yield any further values."
 msgstr ""
+"A l'intérieur d'un générateur, ``return value`` lève l'exception "
+"``StopIteration(value)`` depuis la méthode :meth:`~generator.__next__`. "
+"Après cela, ou une fois que la fin de la fonction est atteinte, le "
+"traitement des valeurs prend fin et le générateur ne peut plus renvoyer de "
+"nouvelles valeurs."
 
 #: ../Doc/howto/functional.rst:490
 msgid ""
@@ -583,6 +865,13 @@ msgid ""
 "method increment ``self.count`` and return it. However, for a moderately "
 "complicated generator, writing a corresponding class can be much messier."
 msgstr ""
+"On peut aussi obtenir l'effet des générateurs manuellement en écrivant nos "
+"propres classes et en sauvegardant les variables locales du générateur comme "
+"des variables d'instance. Par exemple, on peut renvoyer une liste d'entiers "
+"en assignant ``self.count`` à 0 dans un premier temps et en le faisant "
+"incrémenter et renvoyer par `` la méthode :meth:`~iterator.__next__` après "
+"initialisation. Cependant pour un générateur modérément plus compliqué, "
+"écrire une classe équivalente peut devenir un vrai casse-tête."
 
 #: ../Doc/howto/functional.rst:498
 msgid ""
@@ -591,6 +880,10 @@ msgid ""
 "one generator that implements an in-order traversal of a tree using "
 "generators recursively. ::"
 msgstr ""
+"La suite de tests incluse dans la librairie de Python, :source:`Lib/test/"
+"test_generators.py`, contient d'autres exemples intéréssants. Voici un "
+"générateur qui implémente la traversée infixe d'un arbre en utilisant les "
+"générateurs récursivement. ::"
 
 #: ../Doc/howto/functional.rst:514
 msgid ""
@@ -600,10 +893,15 @@ msgid ""
 "knight to every square of an NxN chessboard without visiting any square "
 "twice)."
 msgstr ""
+"Deux autres exemples dans ``test_generators.py`` produisent des solutions "
+"pour le problème des N-dames (placer N dames sur un plateau d'échecs de "
+"dimensions NxN de telle façon qu'aucune dame n'en menace une autre) ou celui "
+"du Cavalier (trouver le chemin que prend un cavalier pour chaque case d'un "
+"plateau de dimensions NxN sans revisiter de case une seconde fois)."
 
 #: ../Doc/howto/functional.rst:522
 msgid "Passing values into a generator"
-msgstr ""
+msgstr "Passer des valeurs à un générateur"
 
 #: ../Doc/howto/functional.rst:524
 msgid ""
@@ -614,6 +912,13 @@ msgid ""
 "variable or by passing in some mutable object that callers then modify, but "
 "these approaches are messy."
 msgstr ""
+"Dans Python 2.4 et ses versions précédentes, les générateurs ne pouvaient "
+"produire qu'une sortie simple. Une fois que le code d'un générateur était "
+"appelé, il n'y avait aucun moyen de passer de nouvelles informations dans la "
+"fonction quand son exécution reprenait. On pouvait simuler ce comportement "
+"en faisant ressembler le générateur à une variable globale ou en passant un "
+"objet mutable que les fonctions appelantes modifiaient a posteriori, mais "
+"ces approches étaient complexes et imparfaites."
 
 #: ../Doc/howto/functional.rst:531
 msgid ""
@@ -621,6 +926,9 @@ msgid ""
 "`yield` became an expression, returning a value that can be assigned to a "
 "variable or otherwise operated on::"
 msgstr ""
+"A partir de Pyhon 2.5, une façon simple de passer des valeurs à un "
+"générateur est apparu, :keyword:`yield` devient une expression, retournant "
+"une valeur qui peut-être assignée ou réutilisée pour une opération::"
 
 #: ../Doc/howto/functional.rst:537
 msgid ""
@@ -629,6 +937,11 @@ msgid ""
 "above example. The parentheses aren't always necessary, but it's easier to "
 "always add them instead of having to remember when they're needed."
 msgstr ""
+"Je vous recommande de **toujours** mettre des parenthèses autour d'un "
+"``yield`` si vous utilisez la valeur de retour pour une opération, comme "
+"dans l'exemple ci-dessus. Les parenthèses ne sont pas toujours nécéssaires, "
+"mais il est plus simple de les mettre à chaque fois plutôt que de se "
+"rappeler quand elles sont nécéssaires."
 
 #: ../Doc/howto/functional.rst:542
 msgid ""
@@ -638,6 +951,11 @@ msgid ""
 "write ``val = yield i`` but have to use parentheses when there's an "
 "operation, as in ``val = (yield i) + 12``.)"
 msgstr ""
+"(:pep:`342` explique les règles exactes, à savoir qu'une expression "
+"``yield`` doit toujours être parenthésée sauf quand elle est la seule "
+"expression du côté droit d'une assignation. On peut donc écrire ``val = "
+"yield i`` mais on doit mettre des parenthèses en présence d'une opération "
+"comme dans ``val = (yield i) + 12``.)"
 
 #: ../Doc/howto/functional.rst:548
 msgid ""
@@ -646,16 +964,23 @@ msgid ""
 "``yield`` expression returns the specified value.  If the regular :meth:"
 "`~generator.__next__` method is called, the ``yield`` returns ``None``."
 msgstr ""
+"Les valeurs sont passées au générateur en appelant sa méthode :meth:"
+"`send(value)<generator.send>`. Celle-ci reprend l'exécution du code du "
+"générateur et le ```yield`` renvoie la valeur passée. Si la méthode "
+"ordinaire :meth:`~generator.__next__` est appelée, le ``yield`` renvoie "
+"``None``."
 
 #: ../Doc/howto/functional.rst:553
 msgid ""
 "Here's a simple counter that increments by 1 and allows changing the value "
 "of the internal counter."
 msgstr ""
+"Voici un simple compteur qui incrémente de 1 et permet le changement de la "
+"valeur du compteur interne."
 
 #: ../Doc/howto/functional.rst:568
 msgid "And here's an example of changing the counter:"
-msgstr ""
+msgstr "Et voici un exemple de changement du compteur:"
 
 #: ../Doc/howto/functional.rst:585
 msgid ""
@@ -664,12 +989,18 @@ msgid ""
 "that the :meth:`~generator.send` method will be the only method used to "
 "resume your generator function."
 msgstr ""
+"``yield`` renvoie souvent ``None``, en conséquence vous devriez toujours "
+"tester cette valeur. N'utilisez pas juste la valeur de retour dans des "
+"expressions à moins d'être certain que la méthode :meth:`~generator.send` "
+"soit la seule méthode utilisée pour reprendre le cours du générateur."
 
 #: ../Doc/howto/functional.rst:590
 msgid ""
 "In addition to :meth:`~generator.send`, there are two other methods on "
 "generators:"
 msgstr ""
+"Deux autres méthodes sur les générateurs viennent compléter :meth:"
+"`~generator.send`:"
 
 #: ../Doc/howto/functional.rst:593
 msgid ""
@@ -677,6 +1008,9 @@ msgid ""
 "raise an exception inside the generator; the exception is raised by the "
 "``yield`` expression where the generator's execution is paused."
 msgstr ""
+":meth:`throw(type, value=None, traceback=None) <generator.throw>` est "
+"utilisée pour lever une exception depuis un générateur; l'exception est "
+"levée depuis un ``yield`` où l'exécution du générateur est pausée."
 
 #: ../Doc/howto/functional.rst:597
 msgid ""
@@ -688,6 +1022,13 @@ msgid ""
 "be called by Python's garbage collector when the generator is garbage-"
 "collected."
 msgstr ""
+":meth:`~generator.close` lève une exception :exc:`GeneratorExit` à "
+"l'intérieur du générateur pour interrompre l'itération. Après interception "
+"de cette exception, le code du générateur doit soit lever :exc:"
+"`GeneratorExit` soit :exc:`StopIteration`; intercepter cette exception et "
+"faire quoi que ce soit d'autre est illégal et déclenchera une :exc:"
+"`RuntimeError`. :meth:`~generator.close` sera aussi appelé par le ramasse-"
+"miettes de Python quand le générateur sera détruit."
 
 #: ../Doc/howto/functional.rst:605
 msgid ""
@@ -695,12 +1036,18 @@ msgid ""
 "suggest using a ``try: ... finally:`` suite instead of catching :exc:"
 "`GeneratorExit`."
 msgstr ""
+"Si vous devez lancer du code de nettoyage après une :exc:`GeneratorExit`, Je "
+"suggère l'utilisation de la structure ``try: ... finally`` plutôt que "
+"d'intercepter :exc:`GeneratorExit`."
 
 #: ../Doc/howto/functional.rst:608
 msgid ""
 "The cumulative effect of these changes is to turn generators from one-way "
 "producers of information into both producers and consumers."
 msgstr ""
+"Les effets cumulés de ces changements ont transformé les générateurs de "
+"simples producteurs d'information en producteurs et consommateurs "
+"d'informations."
 
 #: ../Doc/howto/functional.rst:611
 msgid ""
@@ -710,6 +1057,11 @@ msgid ""
 "can be entered, exited, and resumed at many different points (the ``yield`` "
 "statements)."
 msgstr ""
+"Les générateurs deviennent aussi des **coroutines**, une forme généralisée "
+"des sous-routines. Les sous-routines sont invoqués à un certain point et "
+"terminées à un autre (le début de la fonction au premier ``return`` "
+"rencontré), mais les coroutines peuvent être appelées, terminées et reprises "
+"depuis plusieurs points différents (les ``yield``)."
 
 #: ../Doc/howto/functional.rst:618
 msgid "Built-in functions"
@@ -719,26 +1071,32 @@ msgstr "Fonctions natives"
 msgid ""
 "Let's look in more detail at built-in functions often used with iterators."
 msgstr ""
+"Regardons plus en détail les fonctions natives souvent utilisées avec les "
+"itérateurs."
 
 #: ../Doc/howto/functional.rst:622
 msgid ""
 "Two of Python's built-in functions, :func:`map` and :func:`filter` duplicate "
 "the features of generator expressions:"
 msgstr ""
+"Deux fonctions natives de Python, :func:`map` et :func:`filter` réplique les "
+"fonctionnalités des expressions génératrices:"
 
 #: ../Doc/howto/functional.rst:634
 msgid ""
 ":func:`map(f, iterA, iterB, ...) <map>` returns an iterator over the sequence"
 msgstr ""
+":func:`map(f, iterA, iterB, ...)<map>` renvoie un itérateur sur la séquence"
 
 #: ../Doc/howto/functional.rst:626
 msgid ""
 "``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``."
 msgstr ""
+"``f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...``."
 
 #: ../Doc/howto/functional.rst:636
 msgid "You can of course achieve the same effect with a list comprehension."
-msgstr ""
+msgstr "On peut aussi arriver au même effet avec une compréhension de liste."
 
 #: ../Doc/howto/functional.rst:638
 msgid ""
@@ -748,10 +1106,16 @@ msgid ""
 "truth value of some condition; for use with :func:`filter`, the predicate "
 "must take a single value."
 msgstr ""
+":func:`filter(predicate, iter)<filter>` renvoie un itérateur sur toute la "
+"séquence d'éléments remplissant une certaine condition, et est similairement "
+"répliqué par les compréhensions de liste. Un **prédicat** est une fonction "
+"qui renvoie si une condition est vérifiée ou non; Pour être utilisé avec :"
+"func:`filter`, le prédicat doit prendre une seule valeur."
 
 #: ../Doc/howto/functional.rst:651
 msgid "This can also be written as a list comprehension:"
 msgstr ""
+"Cela peut aussi bien être écrit sous la forme d'une compréhension de listes:"
 
 #: ../Doc/howto/functional.rst:657
 msgid ""
@@ -759,12 +1123,17 @@ msgid ""
 "iterable returning 2-tuples containing the count (from *start*) and each "
 "element. ::"
 msgstr ""
+":func:`enumerate(iter, start=0)<enumerate>` décompte les éléments de "
+"l'itérable en retournant un doublet contenant l'index (depuis *start*) "
+"associé à chaque élément. ::"
 
 #: ../Doc/howto/functional.rst:667
 msgid ""
 ":func:`enumerate` is often used when looping through a list and recording "
 "the indexes at which certain conditions are met::"
 msgstr ""
+":func:`enumerate` est souvent utilisé lors d'une itération sur liste pour "
+"sauvegarder les index d'éléments remplissant certaines conditions::"
 
 #: ../Doc/howto/functional.rst:675
 msgid ""
@@ -773,25 +1142,38 @@ msgid ""
 "result.  The *key* and *reverse* arguments are passed through to the "
 "constructed list's :meth:`~list.sort` method. ::"
 msgstr ""
+":func:`sorted(iterable, key=None, reverse=False)<sorted>` collecte tous les "
+"éléments d'un itérable dans une liste, trie cette liste et renvoie le "
+"résultat trié. Les arguments *key*  et *reverse* sont passés à la liste "
+"construite via la méthode :meth:`~list.sort`. ::"
 
 #: ../Doc/howto/functional.rst:690
 msgid ""
 "(For a more detailed discussion of sorting, see the :ref:`sortinghowto`.)"
 msgstr ""
+"(Pour une discussion plus en profondeur sur le tri, voir :ref:"
+"`sortinghowto`.)"
 
 #: ../Doc/howto/functional.rst:693
+#, fuzzy
 msgid ""
 "The :func:`any(iter) <any>` and :func:`all(iter) <all>` built-ins look at "
 "the truth values of an iterable's contents.  :func:`any` returns ``True`` if "
 "any element in the iterable is a true value, and :func:`all` returns "
 "``True`` if all of the elements are true values:"
 msgstr ""
+"Les fonctions natives :func:`any(iter)<any>` et :func:`all(iter)<all>` "
+"regarde la *truthiness* du contenu d'un itérable. :func:`any` renvoie "
+"``True`` si au moins un élément de l'itérable est une valeur vraie, et :func:"
+"`all` renvoie ``True`` si tous les éléments sont des valeurs vraies:"
 
 #: ../Doc/howto/functional.rst:712
 msgid ""
 ":func:`zip(iterA, iterB, ...) <zip>` takes one element from each iterable "
 "and returns them in a tuple::"
 msgstr ""
+":func:`zip(iterA, iterB, ...)<zip>` prend un élément de chaque itérable et "
+"les retourne sous forme de n-uplet::"
 
 #: ../Doc/howto/functional.rst:718
 msgid ""
@@ -800,6 +1182,10 @@ msgid ""
 "they're requested.  (The technical term for this behaviour is `lazy "
 "evaluation <https://en.wikipedia.org/wiki/Lazy_evaluation>`__.)"
 msgstr ""
+"Les N-uplet sont construits seulement quand ils sont demandés par "
+"l'utilisateur plutôt que de créer une liste complète qui est à peu à peu "
+"épuisée par une suite d'appels successifs. (On appelle ce comportement la "
+"`lazy evaluation <https://en.wikipedia.org/wiki/Lazy_evaluation>`__.)"
 
 #: ../Doc/howto/functional.rst:723
 msgid ""
@@ -807,6 +1193,9 @@ msgid ""
 "length.  If the iterables are of different lengths, the resulting stream "
 "will be the same length as the shortest iterable. ::"
 msgstr ""
+"Cet itérateur est prévu pour être utilisé avec des itérables de même "
+"longueur. Si les itérables sont de différentes longueurs, le flux résultant "
+"sera de la même longueur que le plus court itérable. ::"
 
 #: ../Doc/howto/functional.rst:730
 msgid ""
@@ -814,10 +1203,14 @@ msgid ""
 "the longer iterators and discarded.  This means you can't go on to use the "
 "iterators further because you risk skipping a discarded element."
 msgstr ""
+"Vous devriez éviter ce comportement, néanmoins, car un élément peut être "
+"extrait de l'itérable le plus long et être ignoré. Cela signifie que les "
+"itérateurs ne pourront plus être utilisés par la suite à cause du risque de "
+"passer un élément déjà ignoré."
 
 #: ../Doc/howto/functional.rst:736
 msgid "The itertools module"
-msgstr ""
+msgstr "Le module itertools"
 
 #: ../Doc/howto/functional.rst:738
 msgid ""
@@ -825,30 +1218,38 @@ msgid ""
 "well as functions for combining several iterators.  This section will "
 "introduce the module's contents by showing small examples."
 msgstr ""
+"Le module :mod:`itertools` contient un certain nombre d'itérateurs "
+"communément utilisés ainsi que des fonctions pour combiner plusieurs "
+"itérateurs. Cette section introduira le contenu du module à l'aide de petits "
+"exemples."
 
 #: ../Doc/howto/functional.rst:742
 msgid "The module's functions fall into a few broad classes:"
-msgstr ""
+msgstr "Les fonctions du module se divisent en quelques grandes classes:"
 
 #: ../Doc/howto/functional.rst:744
 msgid "Functions that create a new iterator based on an existing iterator."
 msgstr ""
+"Les fonctions qui créent un nouvel itérateur depuis un itérateur existant."
 
 #: ../Doc/howto/functional.rst:745
 msgid "Functions for treating an iterator's elements as function arguments."
 msgstr ""
+"Les fonctions pour manipuler les éléments d'un itérateur comme des arguments "
+"d'une fonction."
 
 #: ../Doc/howto/functional.rst:746
 msgid "Functions for selecting portions of an iterator's output."
 msgstr ""
+"Les fonctions pour sélectionner des portions de la sortie d'un itérateur."
 
 #: ../Doc/howto/functional.rst:747
 msgid "A function for grouping an iterator's output."
-msgstr ""
+msgstr "Une fonction pour grouper la sortie d'un itérateur."
 
 #: ../Doc/howto/functional.rst:750
 msgid "Creating new iterators"
-msgstr ""
+msgstr "Créer de nouveaux itérateurs"
 
 #: ../Doc/howto/functional.rst:752
 msgid ""
@@ -857,6 +1258,9 @@ msgid ""
 "number, which defaults to 0, and the interval between numbers, which "
 "defaults to 1::"
 msgstr ""
+":func:`itertools.count(start, step)<itertools.count>` renvoie un flux infini "
+"de valeurs séparées par le pas donné (1 par défaut). On peut aussi spécifier "
+"la valeur de départ (0 par défaut)::"
 
 #: ../Doc/howto/functional.rst:763
 msgid ""
@@ -865,6 +1269,10 @@ msgid ""
 "from first to last.  The new iterator will repeat these elements "
 "infinitely. ::"
 msgstr ""
+":func:`itertools.cycle(iter)<itertools.cycle>` sauve une copie du contenu "
+"d'un itérable passé en paramètre et renvoie un nouvel itérateur qui renvoie "
+"ses éléments du premier au dernier. Le nouvel itérateur répète ces éléments "
+"à l'infini. ::"
 
 #: ../Doc/howto/functional.rst:770
 msgid ""
@@ -872,6 +1280,8 @@ msgid ""
 "element *n* times, or returns the element endlessly if *n* is not "
 "provided. ::"
 msgstr ""
+":func:`itertools.repeat(elem, [n])<itertools.repeat>`  renvoie l'élément "
+"passé *n* fois ou renvoie l'élément sans fin si aucun *n* n'est passé. ::"
 
 #: ../Doc/howto/functional.rst:778
 msgid ""
@@ -880,6 +1290,10 @@ msgid ""
 "first iterator, then all the elements of the second, and so on, until all of "
 "the iterables have been exhausted. ::"
 msgstr ""
+":func:`itertools.chain(iterA, iterB, ...)<itertools.chain>` prend un nombre "
+"arbitraire d'itérables en entrée, et renvoie tous les éléments du premier "
+"itérateur, puis tous les éléments du second, et ce jusqu'à ce que tous les "
+"itérables aient été parcourus. ::"
 
 #: ../Doc/howto/functional.rst:786
 msgid ""
@@ -891,6 +1305,13 @@ msgid ""
 "and list slicing, you can't use negative values for *start*, *stop*, or "
 "*step*. ::"
 msgstr ""
+":func:`itertools.isslice(iter, [start], stop, [step])<itertools.isslice>` "
+"renvoie un flux qui est une portion de l'itérateur. Avec un seul argument "
+"*stop*, il renverra les *stop* premiers éléments. Si on fournit un index de "
+"départ, on obtient *stop-start* éléments et si on fournit une valeur en tant "
+"que *step*, des éléments seront passés à chaque itération. Contrairement aux "
+"chaînes Python et à la découpe de listes, *start*, *stop* et *step* ne "
+"peuvent être négatives. ::"
 
 #: ../Doc/howto/functional.rst:800
 msgid ""
@@ -901,10 +1322,17 @@ msgid ""
 "iterator, so this can consume significant memory if the iterator is large "
 "and one of the new iterators is consumed more than the others. ::"
 msgstr ""
+":func:`itertools.tee(iter, [n])<itertools.tee>` réplique un itérateur; il "
+"renvoie *n* itérateurs indépendants qui retourneront tous le contenu de "
+"l'itérateur source. Si aucune valeur n'est donnée à *n*, elle est affectée "
+"par défaut à 2. Répliquer des itérateurs nécéssite de sauvegarder le contenu "
+"de l'itérateur source, cela peut consommer beaucoup de mémoire si "
+"l'itérateur est important et que l'un des nouvels itérateurs est plus "
+"souvent consommé que les autres. ::"
 
 #: ../Doc/howto/functional.rst:819
 msgid "Calling functions on elements"
-msgstr ""
+msgstr "Appeler des fonctions sur des éléments"
 
 #: ../Doc/howto/functional.rst:821
 msgid ""
@@ -914,6 +1342,11 @@ msgid ""
 "``a != b``), and :func:`operator.attrgetter('id') <operator.attrgetter>` "
 "(returns a callable that fetches the ``.id`` attribute)."
 msgstr ""
+"Le module :mod:`operator` contient un ensemble de fonctions correspondant "
+"aux opérateurs Python. On retrouve par exemple :func:`operator.add(a, "
+"b)<operator.add>` qui ajoute deux valeurs, :func:`operator.ne(a, b)<operator."
+"ne>` (pareil que ``a != b``) et :func:`operator.attrgetter('id')<operator."
+"attrgetter>` (renvoie un membre appelable qui récupère l'attribut ``.id``)."
 
 #: ../Doc/howto/functional.rst:827
 msgid ""
@@ -921,16 +1354,21 @@ msgid ""
 "iterable will return a stream of tuples, and calls *func* using these tuples "
 "as the arguments::"
 msgstr ""
+":func:`itertools.starmap(func, iter)<itertools.starmap>`  suppose que "
+"l'itérable renverra un flux de N-uplet, et appellera *func* utilisant chaque "
+"N-uplet comme ensemble d'arguments à passer::"
 
 #: ../Doc/howto/functional.rst:839
 msgid "Selecting elements"
-msgstr ""
+msgstr "Sélectionner des éléments"
 
 #: ../Doc/howto/functional.rst:841
 msgid ""
 "Another group of functions chooses a subset of an iterator's elements based "
 "on a predicate."
 msgstr ""
+"Un autre groupe de fonctions choisit un sous-ensemble des éléments renvoyé "
+"par un itérateur en fonction d'un prédicat."
 
 #: ../Doc/howto/functional.rst:844
 msgid ""
@@ -938,6 +1376,9 @@ msgid ""
 "the opposite of :func:`filter`, returning all elements for which the "
 "predicate returns false::"
 msgstr ""
+":func:`itertools.filterfalse(predicate, iter)<itertools.filterfalse>` est "
+"l'opposé de :func:`filter`, il retourne tous les éléments pour lesquels le "
+"prédicat n'est pas vérifié::"
 
 #: ../Doc/howto/functional.rst:851
 msgid ""
@@ -945,6 +1386,9 @@ msgid ""
 "elements for as long as the predicate returns true.  Once the predicate "
 "returns false, the iterator will signal the end of its results. ::"
 msgstr ""
+":func:`itertools.takewhile(predicate, iter)<itertools.takewhile>` renvoie "
+"les éléments tant que le prédicat est vérifié. Dès que le prédicat est faux, "
+"l'itérateur s'arrête de renvoyer des éléments. ::"
 
 #: ../Doc/howto/functional.rst:864
 msgid ""
@@ -952,6 +1396,9 @@ msgid ""
 "elements while the predicate returns true, and then returns the rest of the "
 "iterable's results. ::"
 msgstr ""
+":func:`itertools.dropwhile(predicate, iter)<itertools.dropwhile>` passe les "
+"éléments tant que le prédicat est vérifié et les renvoie dès qu'il ne l'est "
+"plus. ::"
 
 #: ../Doc/howto/functional.rst:874
 msgid ""
@@ -960,10 +1407,14 @@ msgid ""
 "corresponding element of *selectors* is true, stopping whenever either one "
 "is exhausted::"
 msgstr ""
+":func:`itertools.compress(data, selectors)<itertools.compress>` prend deux "
+"itérateurs et renvoie seulement les éléments de *data* pour lesquels "
+"l'élément correspondant dans *selectors* est vrai, s'arrêtant dès que l'un "
+"des deux est épuisé::"
 
 #: ../Doc/howto/functional.rst:883
 msgid "Combinatoric functions"
-msgstr ""
+msgstr "Fonctions combinatoires"
 
 #: ../Doc/howto/functional.rst:885
 msgid ""
@@ -971,6 +1422,9 @@ msgid ""
 "returns an iterator giving all possible *r*-tuple combinations of the "
 "elements contained in *iterable*.  ::"
 msgstr ""
+"La fonction :func:`itertools.combinations(iterable, r)<itertools."
+"combinations>` renvoie un itérateur donnant toutes les combinaisons "
+"possibles *r* N-uplet des éléments contenus dans *iterable*. ::"
 
 #: ../Doc/howto/functional.rst:900
 msgid ""
@@ -980,24 +1434,36 @@ msgid ""
 "permutations(iterable, r=None) <itertools.permutations>`, removes this "
 "constraint on the order, returning all possible arrangements of length *r*::"
 msgstr ""
+"Les éléments de chaque N-uplet restent dans le même ordre qu'*iterable* les "
+"a renvoyé. Par exemple, le nombre 1 est toujours devant 2, 3, 4 ou 5 dans "
+"les exemples ci-dessus. Une fonction similaire, :func:`itertools."
+"permutations(iterable, r=None)<itertools.permutations>`, enlève cette "
+"contrainte d'ordre, renvoyant tous les arrangements possibles de longueur "
+"*r*::"
 
 #: ../Doc/howto/functional.rst:919
 msgid ""
 "If you don't supply a value for *r* the length of the iterable is used, "
 "meaning that all the elements are permuted."
 msgstr ""
+"Si aucune valeur n'est donnée à *r*, la longueur de l'itérable est utilisée, "
+"cela implique que tous les éléments seront permutés."
 
 #: ../Doc/howto/functional.rst:922
 msgid ""
 "Note that these functions produce all of the possible combinations by "
 "position and don't require that the contents of *iterable* are unique::"
 msgstr ""
+"Ces fonctions produisent toutes les combinaisons possibles par position et "
+"ne nécéssitent donc pas que le contenu d'*iterable* soit unique::"
 
 #: ../Doc/howto/functional.rst:929
 msgid ""
 "The identical tuple ``('a', 'a', 'b')`` occurs twice, but the two 'a' "
 "strings came from different positions."
 msgstr ""
+"Le même triplet  ``('a', 'a', 'b')`` est présent deux fois, ,mais les deux "
+"chaînes 'a' viennent de positions différentes."
 
 #: ../Doc/howto/functional.rst:932
 msgid ""
@@ -1007,10 +1473,15 @@ msgid ""
 "selected for the first position of each tuple and then is replaced before "
 "the second element is selected.  ::"
 msgstr ""
+"La fonction :func:`itertools.combinations_with_replacement(iterable, "
+"r)<itertools.combinations_with_replacement>` assouplit une autre contrainte: "
+"les éléments peuvent être répétés dans un N-uplet. Conceptuellement un "
+"élément est choisi pour la première position de chaque N-uplet et est "
+"ensuite remplacé avant que le second élément soit choisi. ::"
 
 #: ../Doc/howto/functional.rst:947
 msgid "Grouping elements"
-msgstr ""
+msgstr "Grouper des éléments"
 
 #: ../Doc/howto/functional.rst:949
 msgid ""
@@ -1020,6 +1491,11 @@ msgid ""
 "element returned by the iterable.  If you don't supply a key function, the "
 "key is simply each element itself."
 msgstr ""
+"La dernière fonction dont nous discuterons, :func:`itertools.groupby(iter, "
+"key_func=None)<itertools.groupby>`, est la plus compliquée. "
+"``key_func(elem)`` est une fonction qui peut calculer une clé pour chaque "
+"élément retourné par l'itérable. Si aucune fonction n'est fournie, chaque "
+"clé est simplement l'élément lui-même."
 
 #: ../Doc/howto/functional.rst:954
 msgid ""
@@ -1027,6 +1503,9 @@ msgid ""
 "underlying iterable that have the same key value, and returns a stream of 2-"
 "tuples containing a key value and an iterator for the elements with that key."
 msgstr ""
+":func:`~itertools.groupby` collecte tous les éléments consécutifs de "
+"l'itérable sous-jacent qui ont la même clé, et renvoie un flux de doublet "
+"contenant une clé et un itérateur pour les éléments avec cette clé."
 
 #: ../Doc/howto/functional.rst:982
 msgid ""
@@ -1035,10 +1514,15 @@ msgid ""
 "also use the underlying iterable, so you have to consume the results of "
 "iterator-1 before requesting iterator-2 and its corresponding key."
 msgstr ""
+":func:`~itertools.groupby`  suppose que le contenu de l'itérable sous-jacent "
+"sera déjà trié en fonction de la clé. On peut noter que les itérateurs "
+"retournés utiliseront aussi l'itérable sous-jacent, vous devez donc "
+"consommer les résultats de l'itérateur -1 avant de demander l'itérateur -2 "
+"et sa clé correspondante."
 
 #: ../Doc/howto/functional.rst:989
 msgid "The functools module"
-msgstr ""
+msgstr "Le module functools"
 
 #: ../Doc/howto/functional.rst:991
 msgid ""
@@ -1047,6 +1531,10 @@ msgid ""
 "and returns a new function.  The most useful tool in this module is the :"
 "func:`functools.partial` function."
 msgstr ""
+"Le module :mod:`functools dans Python 2.5 contient des fonctions d'ordre "
+"supérieur. Une **fonction d'ordre supérieur** prend une ou plusieurs "
+"fonctions en entrée et renvoie une nouvelle fonction. L'outil le plus utile "
+"de ce module est la fonction :func:`functools.partial`."
 
 #: ../Doc/howto/functional.rst:996
 msgid ""
@@ -1057,6 +1545,12 @@ msgid ""
 "filling in a value for one of ``f()``'s parameters.  This is called "
 "\"partial function application\"."
 msgstr ""
+"Pour des programmes écrits dans un style purement fonctionnel, on veut "
+"parfois construire des variantes de fonctions déjà existantes qui ont des "
+"paramètres par défaut. Prenons la fonction Python ``f(a, b, c)``; on "
+"pourrait vouloir créer une nouvelle fonction ``g(b, c)`` qui équivaudrait à "
+"``f(1, b, c)``; on remplit une valeur pour les paramètres de ``f()``. On "
+"appelle cela \"application partielle de la fonction\"."
 
 #: ../Doc/howto/functional.rst:1002
 msgid ""
@@ -1065,6 +1559,10 @@ msgid ""
 "resulting object is callable, so you can just call it to invoke ``function`` "
 "with the filled-in arguments."
 msgstr ""
+"Le constructeur de :func:`~functools.partial` prend les arguments "
+"``(function, arg1, arg2, ..., kwarg1=value1, kwarg2=value2)``.  L'objet "
+"résultant est appelable; on peut l'appeler pour invoquer ``function`` avec "
+"les arguments déjà remplis."
 
 #: ../Doc/howto/functional.rst:1007
 msgid "Here's a small but realistic example::"
@@ -1084,6 +1582,18 @@ msgid ""
 "If the initial value is supplied, it's used as a starting point and "
 "``func(initial_value, A)`` is the first calculation. ::"
 msgstr ""
+":func:`functools.reduce(func, iter, [initial_value])<functools.reduce>` "
+"effectue de manière cumulative une opération sur l'ensemble des éléments de "
+"l'itérable (elle ne peut donc pas être utilisé sur des itérables infinis). "
+"*func* doit être une fonction qui prend deux arguments et renvoie une seule "
+"valeur.  :func:`functools.reduce` prend les deux premiers éléments A et B "
+"renvoyés par l'itérateur et calcule ``func(A, B)``. Il récupère ensuite le "
+"troisième élément, C, calcule ``func(func(A, B), C)``, combine le résultat "
+"avec le quatrième élément et continue comme cela jusqu'à ce que l'itérable "
+"soit épuisé. Si l'itérable ne retourne aucune valeur, une exception :exc:"
+"`TypeError` est levée. Si une valeur initiale est fournie; elle est utilisée "
+"comme point de départ et la première opération correspond à "
+"``func(initial_value, A)``. ::"
 
 #: ../Doc/howto/functional.rst:1043
 msgid ""
@@ -1091,12 +1601,18 @@ msgid ""
 "all the elements of the iterable.  This case is so common that there's a "
 "special built-in called :func:`sum` to compute it:"
 msgstr ""
+"Si vous utilisez :func:`operator.add` avec :func:`functools.reduce`, vous "
+"allez additionner les éléments de l'itérable. Cette opération est tellement "
+"courante qu'une fonction native dédiée existe: :func:`sum`:"
 
 #: ../Doc/howto/functional.rst:1055
 msgid ""
 "For many uses of :func:`functools.reduce`, though, it can be clearer to just "
 "write the obvious :keyword:`for` loop::"
 msgstr ""
+"Il se peut néanmoins que pour beaucoup d'utilisations de :func:`functools."
+"reduce`, l'usage d'une simple boucle :keyword:`for` soit plus "
+"compréhensible::"
 
 #: ../Doc/howto/functional.rst:1067
 msgid ""
@@ -1105,10 +1621,14 @@ msgid ""
 "of returning only the final result, :func:`accumulate` returns an iterator "
 "that also yields each partial result::"
 msgstr ""
+"Une fonction associée est :func:`itertools.accumulate(iterable, "
+"func=operator.add) <itertools.accumulate>`.  Elle effectue la même "
+"opération, mais au lieu de renvoyer seulement le résultat final, :func:"
+"`accumulate` renvoie un itérateur composé des résultats intermédiaires::"
 
 #: ../Doc/howto/functional.rst:1080
 msgid "The operator module"
-msgstr ""
+msgstr "Le module opérateur"
 
 #: ../Doc/howto/functional.rst:1082
 msgid ""
@@ -1117,53 +1637,66 @@ msgid ""
 "useful in functional-style code because they save you from writing trivial "
 "functions that perform a single operation."
 msgstr ""
+"Le module :mod:`operator` a été mentionné plus tôt. Il contient un ensemble "
+"de fonctions correspondant aux opérateurs Python. Ces fonctions sont souvent "
+"utiles dans du code écrit dans un style fonctionnel car elles vous évitent "
+"d'écrire des fonctions triviales qui n'effectue qu'une seule opération."
 
 #: ../Doc/howto/functional.rst:1087
 msgid "Some of the functions in this module are:"
-msgstr ""
+msgstr "Quelques fonctions de ce module sont:"
 
 #: ../Doc/howto/functional.rst:1089
 msgid ""
 "Math operations: ``add()``, ``sub()``, ``mul()``, ``floordiv()``, "
 "``abs()``, ..."
 msgstr ""
+"Opérations mathématiques: ``add()``, ``sub()``, ``mul()``, ``floordiv()``, "
+"``abs()``, ..."
 
 #: ../Doc/howto/functional.rst:1090
 msgid "Logical operations: ``not_()``, ``truth()``."
-msgstr ""
+msgstr "Opérations logiques: ``not_()``, ``truth()``."
 
 #: ../Doc/howto/functional.rst:1091
 msgid "Bitwise operations: ``and_()``, ``or_()``, ``invert()``."
-msgstr ""
+msgstr "Opérations bitwise: ``and_()``, ``or_()``, ``invert()``."
 
 #: ../Doc/howto/functional.rst:1092
 msgid ""
 "Comparisons: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, and ``ge()``."
 msgstr ""
+"Comparaisons: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, et ``ge()``."
 
 #: ../Doc/howto/functional.rst:1093
 msgid "Object identity: ``is_()``, ``is_not()``."
-msgstr ""
+msgstr "Nature d'un objet: ``is_()``, ``is_not()``."
 
 #: ../Doc/howto/functional.rst:1095
 msgid "Consult the operator module's documentation for a complete list."
 msgstr ""
+"Consultez la documentation du module opérateur pour une liste complète."
 
 #: ../Doc/howto/functional.rst:1099
 msgid "Small functions and the lambda expression"
-msgstr ""
+msgstr "Fonctions courtes et les expressions lambda"
 
 #: ../Doc/howto/functional.rst:1101
 msgid ""
 "When writing functional-style programs, you'll often need little functions "
 "that act as predicates or that combine elements in some way."
 msgstr ""
+"On ressent souvent le besoin de petites fonctions qui agissent tel des "
+"prédicats ou qui combinent des éléments d'une certaine façon lors de "
+"l'écriture de programmes dans un style fonctionnel."
 
 #: ../Doc/howto/functional.rst:1104
 msgid ""
 "If there's a Python built-in or a module function that's suitable, you don't "
 "need to define a new function at all::"
 msgstr ""
+"Si une fonction native ou issue d'un module convient pour l'usage, pas "
+"besoin de réécrire de nouvelle fonction::"
 
 #: ../Doc/howto/functional.rst:1110
 msgid ""
@@ -1173,18 +1706,25 @@ msgid ""
 "parameters, and creates an anonymous function that returns the value of the "
 "expression::"
 msgstr ""
+"Si la fonction désirée n'existe pas, il va falloir l'écrire. On peut écrire "
+"de courtes fonctions en utilisant le mot-clé :keyword:`lambda` expression.  "
+"``lambda``  prend  des paramètres et une expression combinant ces "
+"paramètres, et crée une fonction anonyme qui renvoie le résultat de cette "
+"expression::"
 
 #: ../Doc/howto/functional.rst:1119
 msgid ""
 "An alternative is to just use the ``def`` statement and define a function in "
 "the usual way::"
-msgstr ""
+msgstr "On peut aussi écrire une fonction classique avec le mot-clé ``def``::"
 
 #: ../Doc/howto/functional.rst:1128
 msgid ""
 "Which alternative is preferable?  That's a style question; my usual course "
 "is to avoid using ``lambda``."
 msgstr ""
+"Quelle alternative est préférable? C'est une question de style; ``lambda`` "
+"est la syntaxe préférée pour le style fonctionnel."
 
 #: ../Doc/howto/functional.rst:1131
 msgid ""
@@ -1195,6 +1735,13 @@ msgid ""
 "``lambda`` statement, you'll end up with an overly complicated expression "
 "that's hard to read.  Quick, what's the following code doing? ::"
 msgstr ""
+"J'évite d'utiliser ``lambda`` par habitude. ``lambda`` est en effet assez "
+"limité dans les fonctions qu'elle peut définir. Le résultat doit être "
+"calculable à l'aide d'une seule expression, ce qui signifie qu'on ne peut "
+"avoir de conditions type ``if... elif... else`` ou de `` try... except``. Si "
+"on crée une ``lambda`` faisant beaucoup d'opérations, on se retrouve avec "
+"une expression complexe, difficile à lire. Tenez, dites-moi rapidement ce "
+"que fait ce code ::"
 
 #: ../Doc/howto/functional.rst:1141
 msgid ""
@@ -1202,58 +1749,69 @@ msgid ""
 "figure out what's going on.  Using a short nested ``def`` statements makes "
 "things a little bit better::"
 msgstr ""
+"On peut comprendre le but de ce code, mais cela prend du temps de démêler "
+"l'expression pour savoir ce qu'il s'y passe. Utiliser de courtes fonctions "
+"(définies avec ``def``) imbriquées peut aider à simplifier la chose::"
 
 #: ../Doc/howto/functional.rst:1151
 msgid "But it would be best of all if I had simply used a ``for`` loop::"
-msgstr ""
+msgstr "Mais il aurait été plus simple d'utiliser juste une boucle ``for``::"
 
 #: ../Doc/howto/functional.rst:1157
 msgid "Or the :func:`sum` built-in and a generator expression::"
-msgstr ""
+msgstr "Ou la fonction native :func:`sum`  et une expression génératrice::"
 
 #: ../Doc/howto/functional.rst:1161
 msgid ""
 "Many uses of :func:`functools.reduce` are clearer when written as ``for`` "
 "loops."
 msgstr ""
+"Beaucoup d'utilisations de :func:`functools.reduce` sont plus simples "
+"écrites à l'aide de boucles ``for``."
 
 #: ../Doc/howto/functional.rst:1163
 msgid ""
 "Fredrik Lundh once suggested the following set of rules for refactoring uses "
 "of ``lambda``:"
 msgstr ""
+"Fredrik Lundh suggéra cet ensemble de règles pour redéfinir les utilisations "
+"de ``lambda``:"
 
 #: ../Doc/howto/functional.rst:1166
 msgid "Write a lambda function."
-msgstr ""
+msgstr "Ecrivez une fonction lambda."
 
 #: ../Doc/howto/functional.rst:1167
 msgid "Write a comment explaining what the heck that lambda does."
-msgstr ""
+msgstr "Ecrivez un commentaire à propos de ce que fait cette fichue lambda."
 
 #: ../Doc/howto/functional.rst:1168
 msgid ""
 "Study the comment for a while, and think of a name that captures the essence "
 "of the comment."
 msgstr ""
+"Etudiez le commentaire pendant un moment, et réfléchissez à un nom qui "
+"capture l'essence du commentaire."
 
 #: ../Doc/howto/functional.rst:1170
 msgid "Convert the lambda to a def statement, using that name."
-msgstr ""
+msgstr "Convertissez la lambda en une fonction, en utilisant ce nom."
 
 #: ../Doc/howto/functional.rst:1171
 msgid "Remove the comment."
-msgstr ""
+msgstr "Enlevez le commentaire."
 
 #: ../Doc/howto/functional.rst:1173
 msgid ""
 "I really like these rules, but you're free to disagree about whether this "
 "lambda-free style is better."
 msgstr ""
+"J'aime beaucoup ces règles, mais libre à vous de décider si ce style dénué "
+"de lambda vous convient ou non."
 
 #: ../Doc/howto/functional.rst:1178
 msgid "Revision History and Acknowledgements"
-msgstr ""
+msgstr "Historique des Révisions et Remerciements"
 
 #: ../Doc/howto/functional.rst:1180
 msgid ""
@@ -1262,31 +1820,43 @@ msgid ""
 "Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike "
 "Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton."
 msgstr ""
+"L'auteur aimerait remercier les personnes suivantes pour avoir proposé des "
+"suggestions, des corrections, de l'aide sur les différentes ébauches de cet "
+"article: Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim "
+"Jewett, Mike Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake "
+"Winton, Louis Portay."
 
 #: ../Doc/howto/functional.rst:1185
 msgid "Version 0.1: posted June 30 2006."
-msgstr ""
+msgstr "Version 0.1: postée le 30 Juin 2006."
 
 #: ../Doc/howto/functional.rst:1187
 msgid "Version 0.11: posted July 1 2006.  Typo fixes."
-msgstr ""
+msgstr "Version 0.11: postée le 1er Juillet 2006.  Corrections de Typo."
 
 #: ../Doc/howto/functional.rst:1189
 msgid ""
 "Version 0.2: posted July 10 2006.  Merged genexp and listcomp sections into "
 "one. Typo fixes."
 msgstr ""
+"Version 0.2: postée le 10 Juillet 2006. Fusion des sections genexp and "
+"listcomp en une seule. Corrections de typo."
 
 #: ../Doc/howto/functional.rst:1192
 msgid ""
 "Version 0.21: Added more references suggested on the tutor mailing list."
 msgstr ""
+"Version 0.21: Ajout de nouvelles références suggérées sur la liste de "
+"diffusion des tuteurs."
 
 #: ../Doc/howto/functional.rst:1194
 msgid ""
 "Version 0.30: Adds a section on the ``functional`` module written by Collin "
 "Winter; adds short section on the operator module; a few other edits."
 msgstr ""
+"Version 0.30: Ajout d'une section sur le module ``functional`` écrit par "
+"Collin Winter; ajout d'une courte section sur le module des opérateurs; "
+"quelques autres modifications."
 
 #: ../Doc/howto/functional.rst:1199
 msgid "References"
@@ -1294,7 +1864,7 @@ msgstr "Références"
 
 #: ../Doc/howto/functional.rst:1202
 msgid "General"
-msgstr ""
+msgstr "Général"
 
 #: ../Doc/howto/functional.rst:1204
 msgid ""
@@ -1306,6 +1876,13 @@ msgid ""
 "approaches described in these chapters are applicable to functional-style "
 "Python code."
 msgstr ""
+"**Structure and Interpretation of Computer Programs**, par Harold Abelson et "
+"Gerald Jay Sussman avec Julie Sussman. Texte complet (en) https://mitpress."
+"mit.edu/sicp/.  Dans ce livre classique d'informatique, les chapitres 2 et 3 "
+"traitent de l'utilisation de séquences et de flux pour organiser le parcours "
+"de la donnée au sein d'un programme. Ce livre utilise Scheme pour ses "
+"exemples, mais beaucoup de ses approches de conception décrites dans ces "
+"chapitres sont reproductibles avec du Python écrit dans un style fonctionnel."
 
 #: ../Doc/howto/functional.rst:1212
 msgid ""
@@ -1313,25 +1890,33 @@ msgid ""
 "functional programming that uses Java examples and has a lengthy historical "
 "introduction."
 msgstr ""
+"http://www.defmacro.org/ramblings/fp.html: Une introduction générale à la "
+"programmation fonctionnelle qui utilise des exemples écrits en Java et qui "
+"comporte une introduction historique détaillée."
 
 #: ../Doc/howto/functional.rst:1215
 msgid ""
 "https://en.wikipedia.org/wiki/Functional_programming: General Wikipedia "
 "entry describing functional programming."
 msgstr ""
+"https://en.wikipedia.org/wiki/Functional_programming: Entrée Wikipedia "
+"généraliste décrivant la programmation fonctionnelle."
 
 #: ../Doc/howto/functional.rst:1218
 msgid "https://en.wikipedia.org/wiki/Coroutine: Entry for coroutines."
 msgstr ""
+"https://en.wikipedia.org/wiki/Coroutine: Entrée à propos des coroutines."
 
 #: ../Doc/howto/functional.rst:1220
 msgid ""
 "https://en.wikipedia.org/wiki/Currying: Entry for the concept of currying."
 msgstr ""
+"https://en.wikipedia.org/wiki/Currying: Entrée à propos du concept de "
+"currying."
 
 #: ../Doc/howto/functional.rst:1223
 msgid "Python-specific"
-msgstr ""
+msgstr "Spécifique à Python"
 
 #: ../Doc/howto/functional.rst:1225
 msgid ""
@@ -1340,6 +1925,10 @@ msgid ""
 "text processing, in the section titled \"Utilizing Higher-Order Functions in "
 "Text Processing\"."
 msgstr ""
+"http://gnosis.cx/TPiP/: Le premier chapitre du livre de David Mertz :title-"
+"reference:`Text Processing in Python` traite de la programmation "
+"fonctionnelle dans le cadre du traitement de texte, dans la section "
+"intitulée \"Utilizing Higher-Order Functions in Text Processing\"."
 
 #: ../Doc/howto/functional.rst:1230
 msgid ""
@@ -1349,29 +1938,36 @@ msgid ""
 "developerworks/linux/library/l-prog2/index.html>`__, and `part 3 <https://"
 "www.ibm.com/developerworks/linux/library/l-prog3/index.html>`__,"
 msgstr ""
+"Mertz a aussi écrit une série en 3 parties sur la programmation "
+"fonctionnelle pour le site IBM's DeveloperWorks;voir `part 1 <https://www."
+"ibm.com/developerworks/linux/library/l-prog/index.html>`__, `part 2 <https://"
+"www.ibm.com/developerworks/linux/library/l-prog2/index.html>`__, et `part 3 "
+"<https://www.ibm.com/developerworks/linux/library/l-prog3/index.html>`__,"
 
 #: ../Doc/howto/functional.rst:1238
 msgid "Python documentation"
-msgstr ""
+msgstr "Documentation Python"
 
 #: ../Doc/howto/functional.rst:1240
 msgid "Documentation for the :mod:`itertools` module."
-msgstr ""
+msgstr "Documentation pour le module :mod:`itertools`."
 
 #: ../Doc/howto/functional.rst:1242
 msgid "Documentation for the :mod:`functools` module."
-msgstr ""
+msgstr "Documentation pour le module :mod:`functools`."
 
 #: ../Doc/howto/functional.rst:1244
 msgid "Documentation for the :mod:`operator` module."
-msgstr ""
+msgstr "Documentation pour le module :mod:`operator`."
 
 #: ../Doc/howto/functional.rst:1246
 msgid ":pep:`289`: \"Generator Expressions\""
-msgstr ""
+msgstr ":pep:`289`: \"Generator Expressions\""
 
 #: ../Doc/howto/functional.rst:1248
 msgid ""
 ":pep:`342`: \"Coroutines via Enhanced Generators\" describes the new "
 "generator features in Python 2.5."
 msgstr ""
+":pep:`342`: \"Coroutines via Enhanced Generators\" décrit les nouvelles "
+"fonctionnalités associées aux générateurs de Python 2.5."