diff --git a/dict b/dict index 7240f7e3..e45120a3 100644 --- a/dict +++ b/dict @@ -1,3 +1,4 @@ +-uplets 017F 212A Ahlstrom @@ -14,11 +15,13 @@ C99 cadriciel cadriciels Catucci +Composabilité concourance contribués coroutine coroutine coroutines +curryfication Cython d'allocateurs décodables @@ -42,6 +45,7 @@ docstrings encodable Farrugia finaliseur +Frederik Fredrik freeze Guido @@ -75,6 +79,7 @@ Marc-André mémoïsant mémoïsation Mersenne +Mertz métacaractère métacaractères métaclasse @@ -91,6 +96,7 @@ pip pourcent précompilé préemptif +préremplis proleptique py2exe pyc @@ -127,6 +133,7 @@ sérialiseur Serwy shell slot +Smalltalk surprenamment tk tokenisation diff --git a/howto/functional.po b/howto/functional.po index b7bcbd28..8cc82974 100644 --- a/howto/functional.po +++ b/howto/functional.po @@ -6,13 +6,14 @@ 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 \n" +"PO-Revision-Date: 2019-10-11 15:16+0200\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" +"Last-Translator: \n" +"X-Generator: Poedit 2.2.1\n" #: ../Doc/howto/functional.rst:3 msgid "Functional Programming HOWTO" @@ -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,11 @@ msgid "" "term:`iterator`\\s and :term:`generator`\\s and relevant library modules " "such as :mod:`itertools` and :mod:`functools`." msgstr "" +"Dans ce document, nous allons faire un tour des fonctionnalités de Python " +"adaptées à la réalisation d'un programme dans un style fonctionnel. Après " +"une introduction à la programmation fonctionnelle, nous aborderons des " +"outils tels que les :term:`iterator`\\s et les :term:`generator`\\s ainsi " +"que les modules :mod:`itertools` et :mod:`functools`." #: ../Doc/howto/functional.rst:16 msgid "Introduction" @@ -53,11 +59,17 @@ msgid "" "just interested in learning about Python language features, skip to the next " "section on :ref:`functional-howto-iterators`." msgstr "" +"Cette section détaille les fondamentaux de la programmation fonctionnelle. " +"Si seules les fonctionnalités de Python vous intéressent, vous pouvez sauter " +"cette partie et lire 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 permettent de traiter des problèmes selon " +"différentes approches :" #: ../Doc/howto/functional.rst:24 msgid "" @@ -65,6 +77,11 @@ 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 suivent une logique " +"**procédurale** : les programmes sont constitués de listes d'instructions " +"qui détaillent les opérations que l'ordinateur doit appliquer aux entrées du " +"programme. C, Pascal ou encore les interpréteurs de commandes Unix sont des " +"langages procéduraux." #: ../Doc/howto/functional.rst:28 msgid "" @@ -75,6 +92,13 @@ msgid "" "to retrieve, and the SQL engine decides whether to scan tables or use " "indexes, which subclauses should be performed first, etc." msgstr "" +"Les langages **déclaratifs** permettent d'écrire la spécification du " +"problème et laissent l'implémentation du langage trouver une façon efficace " +"de réaliser les calculs nécessaires à sa résolution. SQL est un langage " +"déclaratif que vous êtes susceptible de connaître ; une requête SQL décrit " +"le jeu de données que vous souhaitez récupérer et le moteur SQL choisit de " +"parcourir les tables ou d'utiliser les index, l'ordre de résolution des sous-" +"clauses, etc." #: ../Doc/howto/functional.rst:35 msgid "" @@ -84,6 +108,11 @@ msgid "" "and Python are languages that support object-oriented programming, but don't " "force the use of object-oriented features." msgstr "" +"Les programmes **orientés objet** manipulent des ensembles d'objets. Ceux-ci " +"possèdent un état interne et des méthodes qui interrogent ou modifient cet " +"état d'une façon ou d'une autre. Smalltalk et Java sont deux langages " +"orientés objet. C++ et Python gèrent la programmation orientée objet mais " +"n'imposent pas l'utilisation de telles fonctionnalités." #: ../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** implique de décomposer un problème en un " +"ensemble de fonctions. Dans l'idéal, les fonctions produisent des sorties à " +"partir d'entrées et ne possède pas d'état interne qui soit susceptible de " +"modifier la sortie pour une entrée donnée. Les langages fonctionnels les " +"plus connus sont ceux de la famille ML (Standard ML, OCaml et autres) 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 personnes qui conçoivent des langages de programmation peuvent choisir " +"de privilégier une approche par rapport à une autre. Cela complexifie " +"l'écriture de programmes appliquant un paradigme différent de celui " +"considéré. Certains langages sont multi-paradigmes et gère plusieurs " +"approches différentes. Lisp, C++ et Python sont de tels langage ; vous " +"pouvez écrire des programmes ou des bibliothèques dans un style procédural, " +"orienté objet ou fonctionnel dans chacun d'entre eux. Différentes parties " +"d'une application peuvent être écrites selon des approches différentes ; par " +"exemple, l'interface graphique peut suivre le paradigme orienté objet tandis " +"que la logique de traitement est procédurale ou fonctionnelle." #: ../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 traverse un ensemble de fonctions. " +"Chaque fonction opère sur son entrée et produit une sortie. Le style " +"fonctionnel préconise de ne pas écrire de fonctions ayant des effets de " +"bord, c'est-à-dire qui modifient un état interne ou réalisent d'autres " +"changements qui ne sont pas visibles dans la valeur de sortie de la " +"fonction. Les fonctions qui ne présentent aucun effet de bord sont dites " +"**purement fonctionnelles**. L'interdiction des effets de bord signifie " +"qu'aucune structure de données n'est mise à jour lors de l'exécution du " +"programme ; chaque sortie d'une fonction ne dépend que de son entrée." #: ../Doc/howto/functional.rst:66 msgid "" @@ -128,6 +182,15 @@ 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 en ce qui concerne la pureté des " +"fonctions et ne laissent même pas la possibilité d'assigner des variables " +"avec des expressions telles que ``a = 3`` ou ``c = a + b``, cependant il est " +"difficile d'éviter tous les effets de bord. Afficher un message sur l'écran " +"ou écrire un fichier sur le disque sont des effets de bord. Par exemple, un " +"appel aux fonctions :func:`print` ou :func:`time.sleep` en Python ne renvoie " +"aucune valeur utile ; ces fonctions ne sont appelées que pour leur effet de " +"bord (afficher du texte sur l'écran et mettre en pause l'exécution du " +"programme)." #: ../Doc/howto/functional.rst:74 msgid "" @@ -138,6 +201,13 @@ msgid "" "assignments to local variables, but won't modify global variables or have " "other side effects." msgstr "" +"Les programmes Python écrits dans un style fonctionnel ne poussent " +"généralement pas le curseur de la pureté à l'extrême en interdisant toute " +"entrée/sortie ou les assignations ; ils exhibent une interface fonctionnelle " +"en apparence mais utilisent des fonctionnalités impures en interne. Par " +"exemple, l'implémentation d'une fonction peut assigner dans des variables " +"locales mais ne modifiera pas de variable globale et n'aura pas d'autre " +"effet de bord." #: ../Doc/howto/functional.rst:80 msgid "" @@ -150,6 +220,15 @@ 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ée comme l'opposé de la " +"programmation orientée objet. Les objets encapsulent un état interne ainsi " +"qu'une collection de méthodes qui permettent de modifier cet état. Les " +"programmes consistent à appliquer les bons changements à ces états. La " +"programmation fonctionnelle vous impose d'éviter au maximum ces changements " +"d'états en travaillant sur des données qui traversent un flux de fonctions. " +"En Python, vous pouvez combiner ces deux approches en écrivant des fonctions " +"qui prennent en argument et renvoient des instances représentants des objets " +"de votre application (courriers électroniques, 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 "" +"Programmer sous la contrainte du paradigme fonctionnel peut sembler étrange. " +"Pourquoi vouloir éviter les objets et les effets de bord ? Il existe des " +"avantages théoriques et pratiques au style fonctionnel :" #: ../Doc/howto/functional.rst:93 msgid "Formal provability." -msgstr "" +msgstr "Preuves formelles." #: ../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 "Facilité de débogage et de test." #: ../Doc/howto/functional.rst:100 msgid "Formal provability" -msgstr "" +msgstr "Preuves formelles" #: ../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 avantage théorique est qu'il plus facile de construire une preuve " +"mathématique de l'exactitude d'un programme fonctionnel." #: ../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 souhaité trouver des façons de prouver " +"mathématiquement qu'un programme est correct. Cela ne se borne pas à tester " +"si la sortie d'un programme est correcte sur de nombreuses entrées ou lire " +"le code source et en conclure que le celui-ci semble juste. L'objectif est " +"d'établir une preuve rigoureuse que le programme produit le bon résultat " +"pour toutes les entrées possibles." #: ../Doc/howto/functional.rst:112 msgid "" @@ -204,6 +294,14 @@ 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 d'un programme est d'écrire " +"des **invariants**, c'est-à-dire des propriétés de l'entrée et des variables " +"du programme qui sont toujours vérifiées. Pour chaque ligne de code, il " +"suffit de montrer que si les invariants X et Y sont vrais **avant** " +"l'exécution de cette ligne, les invariants légèrement modifiés X' et Y' sont " +"vérifiés **après** son exécution. Ceci se répète jusqu'à atteindre la fin du " +"programme. À ce stade, les invariants doivent alors correspondre aux " +"propriétés que l'on souhaite que la sortie du programme vérifie." #: ../Doc/howto/functional.rst:120 msgid "" @@ -212,6 +310,10 @@ msgid "" "invariants that were true before the assignment without producing any new " "invariants that can be propagated onward." msgstr "" +"L'aversion du style fonctionnel envers les assignations de variable est " +"apparue car celles-ci sont difficiles à gérer avec cette méthode. Les " +"assignations peuvent rompre des invariants qui étaient vrais auparavant sans " +"pour autant produire de nouveaux invariants qui pourraient être propagés." #: ../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 d'un programme est très peu commode et " +"ne concerne que rarement des logiciels en Python. Même des programmes " +"triviaux nécessitent souvent des preuves s'étalant sur plusieurs pages ; la " +"preuve de l'exactitude d'un programme relativement gros serait gigantesque. " +"Peu, voire aucun, des programmes que vous utilisez quotidiennement " +"(l'interpréteur Python, votre analyseur syntaxique XML, votre navigateur " +"web) ne peuvent être prouvés exacts. Même si vous écriviez ou généreriez une " +"preuve, il faudrait encore vérifier celle-ci. Peut-être qu'elle contient une " +"erreur et que vous pensez désormais, à tort, que vous avez prouvé que votre " +"programme est correct." #: ../Doc/howto/functional.rst:136 msgid "Modularity" -msgstr "" +msgstr "Modularité" #: ../Doc/howto/functional.rst:138 msgid "" @@ -237,14 +349,20 @@ msgid "" "thing than a large function that performs a complicated transformation. " "Small functions are also easier to read and to check for errors." msgstr "" +"Un intérêt plus pratique de la programmation fonctionnelle est qu'elle " +"impose de décomposer le problème en petits morceaux. Les programmes qui en " +"résultent sont souvent plus modulaires. Il est plus simple de spécifier et " +"d'écrire une petite fonction qui ne fait qu'une seule tâche plutôt qu'une " +"grosse fonction qui réalise une transformation complexe. Les petites " +"fonctions sont plus faciles à lire et à vérifier." #: ../Doc/howto/functional.rst:146 msgid "Ease of debugging and testing" -msgstr "" +msgstr "Facilité de débogage et de test" #: ../Doc/howto/functional.rst:148 msgid "Testing and debugging a functional-style program is easier." -msgstr "" +msgstr "Tester et déboguer un programme fonctionnel est plus facile." #: ../Doc/howto/functional.rst:150 msgid "" @@ -254,6 +372,11 @@ msgid "" "intermediate inputs and outputs to quickly isolate the function that's " "responsible for a bug." msgstr "" +"Déboguer est plus simple car les fonctions sont généralement petites et bien " +"spécifiées. Lorsqu'un programme ne fonctionne pas, chaque fonction constitue " +"une étape intermédiaire au niveau de laquelle vous pouvez vérifier que les " +"valeurs sont justes. Vous pouvez observer les entrées intermédiaires et les " +"sorties afin d'isoler rapidement la fonction qui est à l'origine du bogue." #: ../Doc/howto/functional.rst:155 msgid "" @@ -262,10 +385,15 @@ 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 plus faciles car chaque fonction est désormais un sujet " +"potentiel pour un test unitaire. Les fonctions ne dépendent pas d'un état " +"particulier du système qui devrait être répliqué avant d'exécuter un test ; " +"à la place vous n'avez qu'à produire une entrée synthétique et vérifier que " +"le résultat correspond à ce que vous attendez." #: ../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 dans le style fonctionnel, vous écrivez un " +"certain nombre de fonctions avec des entrées et des sorties variables. " +"Certaines de ces fonctions sont inévitablement spécifiques à une application " +"en particulier, mais d'autres peuvent être s'appliquer à de nombreux cas " +"d'usage. Par exemple, une fonction qui liste l'ensemble des fichiers XML " +"d'un répertoire à partir du chemin de celui-ci ou une fonction qui renvoie " +"le contenu d'un fichier à partir de son nom peuvent être utiles dans de " +"nombreuses situations." #: ../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 "" +"Au fur et à mesure, vous constituez ainsi une bibliothèque personnelle " +"d'utilitaires. Souvent, vous pourrez construire de nouveaux programmes en " +"agençant des fonctions existantes dans une nouvelle configuration et en " +"écrivant quelques fonctions spécifiques à votre objectif en cours." #: ../Doc/howto/functional.rst:179 msgid "Iterators" @@ -294,6 +434,8 @@ msgid "" "I'll start by looking at a Python language feature that's an important " "foundation for writing functional-style programs: iterators." msgstr "" +"Commençons par jeter un œil à une des fonctionnalités les plus importantes " +"pour écrire en style fonctionnel avec Python : les itérateurs." #: ../Doc/howto/functional.rst:184 msgid "" @@ -305,6 +447,13 @@ 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 posséder " +"une méthode :meth:`~iterator.__next__` qui ne prend pas d'argument et " +"renvoie toujours l'élément suivant du flux. S'il n'y plus d'élément dans le " +"flux, :meth:`~iterator.__next__` doit lever une exception :exc:" +"`StopIteration`. Toutefois, ce n'est pas indispensable ; il est envisageable " +"d'écrire un itérateur qui produit un flux infini de données." #: ../Doc/howto/functional.rst:192 msgid "" @@ -315,10 +464,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 tente de " +"construire un itérateur qui renvoie le contenu de l'objet (ou ses éléments) " +"en levant une exception :exc:`TypeError` si l'objet ne gère pas l'itération. " +"Plusieurs types de données natifs à Python gèrent l'itération, notamment les " +"listes et les dictionnaires. On appelle :term:`iterable` un objet pour " +"lequel il est possible de construire un itérateur." #: ../Doc/howto/functional.rst:199 msgid "You can experiment with the iteration interface manually:" -msgstr "" +msgstr "Vous pouvez expérimenter avec l'interface d'itération manuellement :" #: ../Doc/howto/functional.rst:217 msgid "" @@ -327,18 +482,27 @@ 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 à travailler sur des objets itérables dans divers contextes " +"et tout particulièrement dans une boucle :keyword:`for`. Dans l'expression " +"``for X in Y``, Y doit être un itérateur ou un objet pour lequel :func:" +"`iter` peut générer un itérateur. Ces deux expressions 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 transformés en listes ou en tuples en appelant " +"les constructeurs respectifs :func:`list` et :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 "" +"Le dépaquetage de séquences fonctionne également sur 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 +514,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 "" +"Certaines fonctions natives telles que :func:`max` et :func:`min` prennent " +"un itérateur en argument et en renvoie le plus grand ou le plus élément. Les " +"opérateurs ``\"in\"`` et ``\"not in\"`` gèrent également les itérateurs : " +"``X in iterator`` est vrai si X a été trouvé dans le flux renvoyé par " +"l'itérateur. Vous rencontrerez bien sûr des problèmes si l'itérateur est " +"infini : :func:`max`, :func:`min` ne termineront jamais et, si l'élément X " +"n'apparaît pas dans le flux, les opérateurs ``\"in\"`` et ``\"not in\"`` non " +"plus." #: ../Doc/howto/functional.rst:255 msgid "" @@ -361,10 +533,18 @@ msgid "" "need to do something different with the same stream, you'll have to create a " "new iterator." msgstr "" +"Notez qu'il n'est possible de parcourir un itérateur que vers l'avant et " +"qu'il est impossible de récupérer l'élément précédent, de réinitialiser " +"l'itérateur ou d'en créer une copie. Des objets itérateurs peuvent offrir " +"ces possibilités de façon facultative, mais le protocole d'itération ne " +"spécifie que la méthode :meth:`~iterator.__next__`. Certaines fonctions " +"peuvent ainsi consommer l'entièreté de la sortie d'un itérateur et, si vous " +"devez utiliser le même flux pour autre chose, vous devrez en créer un " +"nouveau." #: ../Doc/howto/functional.rst:265 msgid "Data Types That Support Iterators" -msgstr "" +msgstr "Types de données itérables" #: ../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 vu précédemment comment les listes et les *tuples* gèrent les " +"itérateurs. En réalité, n'importe quel type de séquence en Python, par " +"exemple les chaînes de caractères, sont itérables." #: ../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 parcourt " +"l'ensemble de ses clés ::" #: ../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 la version 3.7, Python garantit que l'ordre de " +"l'itération sur un dictionnaire est identique à l'ordre d'insertion des " +"clés. Dans les versions précédentes, ce comportement n'était pas spécifié et " +"pouvait varier en fonction de l'implémentation." #: ../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 "" +"Appliquer :func:`iter` sur un dictionnaire produit un itérateur sur ses clés " +"mais il est possible d'obtenir d'autres itérateurs par d'autres méthodes. Si " +"vous souhaitez itérer sur les valeurs ou les paires clé/valeur du " +"dictionnaire, vous pouvez explicitement appeler les méthodes :meth:`~dict." +"values` ou :meth:`~dict.items` pour obtenir l'itérateur idoine." #: ../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` accepte de prendre un itérateur en argument qui " +"renvoie un flux fini de pairs ``(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 gèrent aussi l'itération en appelant la méthode :meth:`~io." +"TextIOBase.readline` jusqu'à ce qu'il n'y ait plus d'autre ligne dans le " +"fichier. Cela signifie que vous pouvez lire l'intégralité d'un fichier de la " +"façon suivante ::" #: ../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 être créés à partir d'un itérable et autorisent " +"l'itération sur les éléments de l'ensemble ::" #: ../Doc/howto/functional.rst:326 msgid "Generator expressions and list comprehensions" -msgstr "" +msgstr "Expressions génératrices et compréhension de listes" #: ../Doc/howto/functional.rst:328 msgid "" @@ -425,6 +627,12 @@ msgid "" "strip off trailing whitespace from each line or extract all the strings " "containing a given substring." msgstr "" +"Deux opérations courantes réalisables sur la sortie d'un itérateur sont 1) " +"effectuer une opération pour chaque élément, 2) extraire le sous-ensemble " +"des éléments qui vérifient une certaine condition. Par exemple, pour une " +"liste de chaînes de caractères, vous pouvez choisir de retirer tous les " +"caractères blancs à la fin de chaque ligne ou extraire toutes les chaînes " +"contenant une sous-chaîne précise." #: ../Doc/howto/functional.rst:334 msgid "" @@ -433,11 +641,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 listes et les expressions génératrices sont une façon " +"concise d'exprimer de telles opérations, inspirées du langage de " +"programmation fonctionnel Haskell (https://www.haskell.org/). Vous pouvez " +"retirer tous les caractères blancs d'un flux de chaînes de caractères à " +"l'aide du code suivant ::" #: ../Doc/howto/functional.rst:347 msgid "" "You can select only certain elements by adding an ``\"if\"`` condition::" msgstr "" +"Vous pouvez ne sélectionner que certains éléments en ajoutant une condition " +"``\"if\"`` ::" #: ../Doc/howto/functional.rst:352 msgid "" @@ -449,6 +664,13 @@ msgid "" "infinite stream or a very large amount of data. Generator expressions are " "preferable in these situations." msgstr "" +"La compréhension de liste retourne une liste Python ; ``stripped_list`` est " +"une liste contenant les lignes après transformation, pas un itérateur. Les " +"expressions génératrices renvoient un itérateur qui calcule les valeurs au " +"fur et à mesure sans toutes les matérialiser d'un seul coup. Cela signifie " +"que les compréhensions de listes ne sont pas très utiles si vous travaillez " +"sur des itérateurs infinis ou produisant une très grande quantité de " +"données. Les expressions génératrices sont préférables dans ce cas." #: ../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 écrites entre parenthèses (\"()\") et les " +"compréhensions de listes entre crochets (\"[]\"). Les expressions " +"génératrices sont de 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 "" +"La compréhension de liste équivalente s'écrit de la même à l'exception de " +"l'utilisation des crochets à la place des parenthèses." #: ../Doc/howto/functional.rst:375 msgid "" @@ -470,6 +697,9 @@ msgid "" "``expression`` is only evaluated and added to the result when ``condition`` " "is true." msgstr "" +"Les éléments de la sortie sont les valeurs successives de ``expression``. La " +"clause ``if`` est facultative ; si elle est présente, ``expression`` ne sera " +"évaluée et ajoutée au résultat que si ``condition`` est vérifiée." #: ../Doc/howto/functional.rst:379 msgid "" @@ -477,6 +707,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 entre " +"parenthèses, mais les parenthèses qui encadrent un appel de fonction " +"comptent aussi. Si vous souhaitez créer un itérateur qui soit immédiatement " +"passé à une fonction, vous pouvez écrire ::" #: ../Doc/howto/functional.rst:385 msgid "" @@ -487,12 +721,20 @@ msgid "" "looped over for each resulting pair of elements from ``sequence1`` and " "``sequence2``." msgstr "" +"Les clauses ``for ... in`` indiquent les séquences sur lesquelles itérer. " +"Celles-ci peuvent être de longueurs différentes car l'itération est réalisée " +"de gauche à droite et non en parallèle. ``sequence2`` est parcourue " +"entièrement pour chaque élément de ``sequence1``. ``sequence3`` est ensuite " +"parcourue dans son intégralité pour chaque paire d'éléments de ``sequence1`` " +"et ``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 "" +"Autrement dit, la compréhension de liste ou une expression génératrice est " +"équivalente au code Python ci-dessous ::" #: ../Doc/howto/functional.rst:408 msgid "" @@ -501,6 +743,10 @@ msgid "" "the lengths of all the sequences. If you have two lists of length 3, the " "output list is 9 elements long:" msgstr "" +"Ainsi lorsque plusieurs clauses ``for ... in`` sont présentes mais sans " +"condition ``if``, la longueur totale de la nouvelle séquence est égale au " +"produit des longueurs des séquences itérées. Si vous travaillez sur deux " +"listes de longueur 3, la sortie contiendra 9 éléments :" #: ../Doc/howto/functional.rst:420 msgid "" @@ -508,6 +754,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 "" +"Afin d'éviter créer une ambiguïté dans la grammaire de Python, " +"``expression`` doit être encadrée par des parenthèses si elle produit un n-" +"uplet. La première compréhension de liste ci-dessous n'est pas valide " +"syntaxiquement, tandis que la seconde l'est ::" #: ../Doc/howto/functional.rst:431 msgid "Generators" @@ -519,6 +769,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 forment une classe spéciale de fonctions qui simplifie la " +"création d'itérateurs. Les fonctions habituelles calculent une valeur et la " +"renvoie, tandis que les générateurs renvoient un itérateur qui produit un " +"flux de valeurs." #: ../Doc/howto/functional.rst:437 msgid "" @@ -532,10 +786,21 @@ msgid "" "function where it left off? This is what generators provide; they can be " "thought of as resumable functions." msgstr "" +"Vous connaissez sans doute le fonctionnement des appels de fonctions en " +"Python ou en C. Lorsqu'une fonction est appelée, un espace de noms privé lui " +"est associé pour ses variables locales. Lorsque le programme atteint une " +"instruction ``return``, les variables locales sont détruites et la valeur " +"est renvoyée à l'appelant. Les appels postérieurs à la même fonction créent " +"un nouvel espace de nom privé et de nouvelles variables locales. Cependant, " +"que se passerait-il si les variables locales n'étaient pas détruites lors de " +"la sortie d'une fonction ? Et s'il était possible de reprendre l'exécution " +"de la fonction là où elle s'était arrêtée ? Les générateurs sont une réponse " +"à ces questions ; vous pouvez considérer qu'il s'agit de fonctions qu'il est " +"possible d'interrompre, puis de relancer sans perdre leur progression." #: ../Doc/howto/functional.rst:446 msgid "Here's the simplest example of a generator function:" -msgstr "" +msgstr "Voici un exemple simple de fonction génératrice :" #: ../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 "" +"N'importe quelle fonction contenant le mot-clé :keyword:`yield` est un " +"générateur ; le compilateur :term:`bytecode` de Python détecte ce mot-clé " +"prend en compte cette particularité de la fonction." #: ../Doc/howto/functional.rst:456 msgid "" @@ -555,16 +823,26 @@ msgid "" "preserved. On the next call to the generator's :meth:`~generator.__next__` " "method, the function will resume executing." msgstr "" +"Lorsque vous appelez une fonction génératrice, celle-ci ne renvoie pas une " +"unique valeur ; elle renvoie un objet générateur qui implémente le protocole " +"d'itération. Lorsque l'expression ``yield`` est exécutée, le générateur " +"renvoie la valeur de ``i``, d'une façon similaire à un ``return``. La " +"différence principale entre ``yield`` et ``return`` est qu'en atteignant " +"l'instruction ``yield``, l'état du générateur est suspendu et les variables " +"locales sont conservées. Lors de l'appel suivant à 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 du 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 "" +"Vous pourriez de façon équivalente écrire ``for i in generate_ints(5)`` ou " +"``a, b, c = generate_ints(3)``." #: ../Doc/howto/functional.rst:485 msgid "" @@ -573,6 +851,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 "" +"Dans une fonction génératrice, l'instruction ``return value`` lève une " +"exception ``StopIteration(value)`` dans la méthode :meth:`~generator." +"__next__`. Lorsque cela se produit (ou que la fin de la fonction est " +"atteinte), le flot de nouvelles valeurs s'arrête et le générateur ne peut " +"plus rien produire." #: ../Doc/howto/functional.rst:490 msgid "" @@ -583,6 +866,13 @@ msgid "" "method increment ``self.count`` and return it. However, for a moderately " "complicated generator, writing a corresponding class can be much messier." msgstr "" +"Vous pouvez obtenir le même comportement que celui des générateurs en " +"écrivant votre propre classe qui stocke les variables locales du générateur " +"comme variables d'instance. Pour renvoyer une liste d'entiers, par exemple, " +"vous pouvez initialiser ``self.count`` à 0 et écrire la méthode :meth:" +"`~iterator.__next__` de telle sorte qu'elle incrémente ``self.count`` puis " +"le renvoie. Cependant, cela devient beaucoup plus complexe pour des " +"générateurs relativement sophistiqués." #: ../Doc/howto/functional.rst:498 msgid "" @@ -591,6 +881,10 @@ msgid "" "one generator that implements an in-order traversal of a tree using " "generators recursively. ::" msgstr "" +":source:`Lib/test/test_generators.py`, la suite de test de la bibliothèque " +"Python, contient de nombreux exemples intéressants. Voici un générateur qui " +"implémente le parcours d'un arbre dans l'ordre en utilisant des générateurs " +"de façon récursive. ::" #: ../Doc/howto/functional.rst:514 msgid "" @@ -600,10 +894,16 @@ msgid "" "knight to every square of an NxN chessboard without visiting any square " "twice)." msgstr "" +"Deux autres exemples de ``test_generators.py`` permettent de résoudre le " +"problème des N Reines (placer *N* reines sur un échiquier de dimensions " +"*NxN* de telle sorte qu'aucune reine ne soit en position d'en prendre une " +"autre) et le problème du cavalier (trouver un chemin permettant au cavalier " +"de visiter toutes les cases d'un échiquier *NxN* sans jamais visiter la même " +"case deux fois)." #: ../Doc/howto/functional.rst:522 msgid "Passing values into a generator" -msgstr "" +msgstr "Transmettre des valeurs au générateur" #: ../Doc/howto/functional.rst:524 msgid "" @@ -614,6 +914,13 @@ msgid "" "variable or by passing in some mutable object that callers then modify, but " "these approaches are messy." msgstr "" +"Avant Python 2.5, les générateurs ne pouvaient que produire des sorties. Une " +"fois le code du générateur exécuté pour créer un itérateur, il était " +"impossible d'introduire de l'information nouvelle dans la fonction mise en " +"pause. Une astuce consistait à reproduire cette fonctionnalité en autorisant " +"le générateur à consulter des variables globales ou en lui passant des " +"objets mutables modifiés hors du générateur, mais ces approches étaient " +"compliquées." #: ../Doc/howto/functional.rst:531 msgid "" @@ -621,6 +928,10 @@ msgid "" "`yield` became an expression, returning a value that can be assigned to a " "variable or otherwise operated on::" msgstr "" +"À partir de Python 2.5, il existe une méthode simple pour transmettre des " +"valeurs à un générateur. Le mot-clé :keyword:`yield` est devenu une " +"expression qui renvoie une valeur sur laquelle il est possible d'opérer et " +"que vous pouvez assigner à une variable ::" #: ../Doc/howto/functional.rst:537 msgid "" @@ -629,6 +940,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 "" +"Comme dans l'exemple ci-dessus, je vous recommande de **toujours** encadrer " +"les expressions ``yield`` par des parenthèses lorsque vous utilisez leur " +"valeur de retour. Elles ne sont pas toujours indispensables mais mieux vaut " +"prévenir que guérir : il est plus facile de les ajouter systématiquement que " +"de prendre le risque de les oublier là où elles sont requises." #: ../Doc/howto/functional.rst:542 msgid "" @@ -638,6 +954,11 @@ msgid "" "write ``val = yield i`` but have to use parentheses when there's an " "operation, as in ``val = (yield i) + 12``.)" msgstr "" +"(les règles exactes de parenthésage sont spécifies dans la :pep:`342` : une " +"expression ``yield`` doit toujours être parenthésée sauf s'il s'agit de " +"l'expression la plus externe du côté droit d'une assignation. Cela signifie " +"que vous pouvez écrire ``val = yield i`` mais que les parenthèses sont " +"requises s'il y a une opération, comme dans ``val = (yield i) + 12``.)" #: ../Doc/howto/functional.rst:548 msgid "" @@ -646,16 +967,23 @@ msgid "" "``yield`` expression returns the specified value. If the regular :meth:" "`~generator.__next__` method is called, the ``yield`` returns ``None``." msgstr "" +"Des valeurs peuvent être transmises à un générateur en appelant sa méthode :" +"meth:`send(value) `. Celle-ci reprend l'exécution du " +"générateur et l'expression ``yield`` renvoie la valeur spécifiée. Si c'est " +"la méthode :meth:`~generator.__next__` habituelle qui est appelée, alors " +"``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 exemple de compteur qui s'incrémente de 1 mais dont il est possible " +"de modifier le compte interne." #: ../Doc/howto/functional.rst:568 msgid "And here's an example of changing the counter:" -msgstr "" +msgstr "Et voici comment il est possible de modifier le compteur :" #: ../Doc/howto/functional.rst:585 msgid "" @@ -664,12 +992,18 @@ msgid "" "that the :meth:`~generator.send` method will be the only method used to " "resume your generator function." msgstr "" +"Puisque ``yield`` renvoie souvent ``None``, vous devez toujours vérifier si " +"c'est le cas. N'utilisez pas la valeur de retour à moins d'être certain que " +"seule la méthode :meth:`~generator.send` sera utilisée pour reprendre " +"l'exécution de la fonction génératrice." #: ../Doc/howto/functional.rst:590 msgid "" "In addition to :meth:`~generator.send`, there are two other methods on " "generators:" msgstr "" +"En plus de :meth:`~generator.send`, il existe deux autres méthodes " +"s'appliquant aux générateurs :" #: ../Doc/howto/functional.rst:593 msgid "" @@ -677,6 +1011,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) ` permet de " +"lever une exception dans le générateur ; celle-ci est levée par l'expression " +"``yield`` à l'endroit où l'exécution a été mise en pause." #: ../Doc/howto/functional.rst:597 msgid "" @@ -688,6 +1025,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` dans le " +"générateur afin de terminer l'itération. Le code du générateur qui reçoit " +"cette exception doit lever à son tour :exc:`GeneratorExit` ou :exc:" +"`StopIteration`. Il est illégal d'attraper cette exception et de faire quoi " +"que ce soit d'autre, ceci déclenche une erreur :exc:`RuntimeError`. Lorsque " +"le ramasse-miette de Python collectera le générateur, il appellera sa " +"méthode :meth:`~generator.close`." #: ../Doc/howto/functional.rst:605 msgid "" @@ -695,12 +1039,18 @@ msgid "" "suggest using a ``try: ... finally:`` suite instead of catching :exc:" "`GeneratorExit`." msgstr "" +"Si vous devez exécuter du code pour faire le ménage lors d'une :exc:" +"`GeneratorExit`, je vous suggère d'utiliser une structure ``try: ... " +"finally`` plutôt que d'attraper :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 "" +"Ces changements cumulés transforment les générateurs de producteurs " +"unidirectionnels d'information vers un statut hybride à la fois producteur " +"et consommateur." #: ../Doc/howto/functional.rst:611 msgid "" @@ -710,6 +1060,12 @@ msgid "" "can be entered, exited, and resumed at many different points (the ``yield`` " "statements)." msgstr "" +"Les générateurs sont également devenus des **coroutines**, une forme " +"généralisée de sous-routine. L'exécution des sous-routines démarre à un " +"endroit et se termine à un autre (au début de la fonction et au niveau de " +"l'instruction ``return``), tandis qu'il est possible d'entrer, de sortir ou " +"de reprendre une coroutine à différents endroits (les instructions " +"``yield``)." #: ../Doc/howto/functional.rst:618 msgid "Built-in functions" @@ -719,26 +1075,34 @@ msgstr "Fonctions natives" msgid "" "Let's look in more detail at built-in functions often used with iterators." msgstr "" +"Voyons un peu plus en détail les fonctions natives souvent utilisées de " +"concert 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 "" +":func:`map` et :func:`filter` sont deux fonctions natives de Python qui " +"clonent les propriétés des expressions génératrices :" #: ../Doc/howto/functional.rst:634 msgid "" ":func:`map(f, iterA, iterB, ...) ` returns an iterator over the sequence" msgstr "" +":func:`map(f, iterA, iterB, ...) ` renvoie un itérateur sur une 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 "" +"Vous pouvez obtenir le même comportement à l'aide d'une compréhension de " +"liste." #: ../Doc/howto/functional.rst:638 msgid "" @@ -748,10 +1112,16 @@ msgid "" "truth value of some condition; for use with :func:`filter`, the predicate " "must take a single value." msgstr "" +":func:`filter(predicate, iter) ` renvoie un itérateur sur l'ensemble " +"des éléments de la séquence qui vérifient une certaine condition. Son " +"comportement peut également être reproduit par une compréhension de liste. " +"Un **prédicat** est une fonction qui renvoie vrai ou faux en fonction d'une " +"certaine condition. Dans le cas de :func:`filter`, le prédicat ne doit " +"prendre qu'un seul argument." #: ../Doc/howto/functional.rst:651 msgid "This can also be written as a list comprehension:" -msgstr "" +msgstr "Cela peut se réécrire sous la forme d'une compréhension de liste :" #: ../Doc/howto/functional.rst:657 msgid "" @@ -759,12 +1129,18 @@ msgid "" "iterable returning 2-tuples containing the count (from *start*) and each " "element. ::" msgstr "" +":func:`enumerate(iter, start=0) ` énumère les éléments de " +"l'itérable en renvoyant des paires contenant le nombre d'éléments déjà " +"listés (depuis le *début*) et l'élément en cours. ::" #: ../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é lorsque l'on souhaite boucler sur une " +"liste tout en listant les indices auxquels une certaine condition est " +"vérifiée ::" #: ../Doc/howto/functional.rst:675 msgid "" @@ -773,11 +1149,17 @@ 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) ` rassemble tous " +"les éléments de l'itérable dans une liste, les classe et renvoie le résultat " +"classé. Les arguments *key* et *reverse* sont passés à la méthode :meth:" +"`~list.sort` de la liste ainsi construite. ::" #: ../Doc/howto/functional.rst:690 msgid "" "(For a more detailed discussion of sorting, see the :ref:`sortinghowto`.)" msgstr "" +"(pour plus de détails sur les algorithmes de tri, se référer à :ref:" +"`sortinghowto`.)" #: ../Doc/howto/functional.rst:693 msgid "" @@ -786,12 +1168,19 @@ msgid "" "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) ` et :func:`all(iter) ` " +"permettent d'observer les valeurs de vérité des éléments d'un itérable. :" +"func:`any` renvoie ``True`` si au moins un élément de l'itérable s'évalue " +"comme vrai et :func:`all` renvoie ``True`` si tous les éléments s'évaluent " +"comme vrai :" #: ../Doc/howto/functional.rst:712 msgid "" ":func:`zip(iterA, iterB, ...) ` takes one element from each iterable " "and returns them in a tuple::" msgstr "" +":func:`zip(iterA, iterB, ...) ` rassemble un élément de chaque itérable " +"dans un n-uplet ::" #: ../Doc/howto/functional.rst:718 msgid "" @@ -800,6 +1189,11 @@ msgid "" "they're requested. (The technical term for this behaviour is `lazy " "evaluation `__.)" msgstr "" +"Cela ne construit pas de liste stockée en mémoire, ni ne vide les itérateurs " +"d'entrée avant de renvoyer sa valeur ; en réalité les tuples sont construits " +"et renvoyés au fur et à mesure (il s'agit techniquement parlant d'un " +"comportement d'`évaluation paresseuse `__)." #: ../Doc/howto/functional.rst:723 msgid "" @@ -807,6 +1201,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 suppose qu'il opère sur des itérables de même longueur. Si la " +"longueur des itérables diffère, le flux résultant aura la même longueur que " +"le plus court des itérables. ::" #: ../Doc/howto/functional.rst:730 msgid "" @@ -814,10 +1211,15 @@ 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 "" +"Toutefois, vous devez éviter de dépendre de ce comportement. En effet un " +"élément d'un des itérables les plus longs peut être retiré puis jeté (car " +"l'autre itérable est trop court). Cela signifie que vous ne pouvez alors " +"plus utiliser cet itérable car vous allez sauter l'élément qui vient d'être " +"jeté." #: ../Doc/howto/functional.rst:736 msgid "The itertools module" -msgstr "" +msgstr "Le module *itertools*" #: ../Doc/howto/functional.rst:738 msgid "" @@ -825,30 +1227,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 de nombreux itérateurs très utilisés, " +"ainsi que des fonctions pour combiner différents itérateurs. Cette section " +"présente le contenu du module au travers de quelques 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 catégories :" #: ../Doc/howto/functional.rst:744 msgid "Functions that create a new iterator based on an existing iterator." msgstr "" +"Les fonctions qui transforment un itérateur existant en un nouvel itérateur." #: ../Doc/howto/functional.rst:745 msgid "Functions for treating an iterator's elements as function arguments." msgstr "" +"Les fonctions qui traitent les éléments d'un itérateur comme les arguments " +"d'une fonction." #: ../Doc/howto/functional.rst:746 msgid "Functions for selecting portions of an iterator's output." msgstr "" +"Les fonctions qui permettent de 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 qui permet de 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 +1267,9 @@ msgid "" "number, which defaults to 0, and the interval between numbers, which " "defaults to 1::" msgstr "" +":func:`itertools.count(start, step) ` renvoie un flux " +"infini de valeurs régulièrement espacées. Vous pouvez spécifier la valeur de " +"départ (par défaut, 0) et l'intervalle entre les nombres (par défaut, 1) ::" #: ../Doc/howto/functional.rst:763 msgid "" @@ -865,6 +1278,9 @@ msgid "" "from first to last. The new iterator will repeat these elements " "infinitely. ::" msgstr "" +":func:`itertools.cycle(iter) ` sauvegarde une copie du " +"contenu de l'itérable passé en argument et renvoie un nouvel itérateur qui " +"produit tous les éléments du premier au dernier et se répète indéfiniment. ::" #: ../Doc/howto/functional.rst:770 msgid "" @@ -872,6 +1288,9 @@ msgid "" "element *n* times, or returns the element endlessly if *n* is not " "provided. ::" msgstr "" +":func:`itertools.repeat(elem, [n]) ` renvoie l'élément " +"passé en argument *n* fois ou répète l'élément à l'infini si *n* n'est pas " +"spécifié. ::" #: ../Doc/howto/functional.rst:778 msgid "" @@ -880,6 +1299,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, ...) ` reçoit un " +"nombre arbitraire d'itérables en entrée et les concatène, renvoyant tous les " +"éléments du premier itérateur, puis tous ceux du second et ainsi de suite " +"jusqu'à ce que tous les itérables aient été épuisés. ::" #: ../Doc/howto/functional.rst:786 msgid "" @@ -891,6 +1314,13 @@ msgid "" "and list slicing, you can't use negative values for *start*, *stop*, or " "*step*. ::" msgstr "" +":func:`itertools.islice(iter, [start], stop, [step]) ` " +"renvoie une portion de l'itérateur. En passant seulement l'argument *stop*, " +"il renvoie les *stop* premiers éléments. En spécifiant un indice de début, " +"vous récupérez *stop - start* éléments et, en spécifiant une valeur pour " +"*step*, tous les éléments multiples du pas seront sautés. Cependant vous ne " +"pouvez pas utiliser de valeurs négatives pour *start*, *stop* ou *step* " +"(contrairement aux listes et chaînes de caractères de Python). ::" #: ../Doc/howto/functional.rst:800 msgid "" @@ -901,10 +1331,16 @@ 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]) ` duplique un itérateur et " +"renvoie *n* itérateurs indépendants, chacun copiant le contenu de " +"l'itérateur source. La valeur par défaut pour *n* est 2. La réplication des " +"itérateurs nécessite la sauvegarde d'une partie du contenu de l'itérateur " +"source, ce qui peut consommer beaucoup de mémoire si l'itérateur est grand " +"et que l'un des nouveaux itérateurs est plus consommé que les autres. ::" #: ../Doc/howto/functional.rst:819 msgid "Calling functions on elements" -msgstr "" +msgstr "Appliquer des fonctions au contenu des itérateurs" #: ../Doc/howto/functional.rst:821 msgid "" @@ -914,6 +1350,11 @@ msgid "" "``a != b``), and :func:`operator.attrgetter('id') ` " "(returns a callable that fetches the ``.id`` attribute)." msgstr "" +"Le module :mod:`operator` rassemble des fonctions équivalentes aux " +"opérateurs Python. Par exemple, :func:`operator.add(a,b) ` " +"additionne deux valeurs, :func:`operator.ne(a, b) ` est " +"équivalent à ``a != b`` et :func:`operator.attrgetter('id') ` renvoie un objet appelable qui récupère l'attribut ``.id``." #: ../Doc/howto/functional.rst:827 msgid "" @@ -921,16 +1362,22 @@ msgid "" "iterable will return a stream of tuples, and calls *func* using these tuples " "as the arguments::" msgstr "" +":func:`itertools.starmap(func, iter) ` suppose que " +"l'itérable renvoie une séquence de tuples et appelle *func* en utilisant " +"chaque n-uplet comme arguments ::" #: ../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 "" +"Une autre catégorie de fonctions sont les fonctions permettant de " +"sélectionner un sous-ensemble des éléments de l'itérateur selon un prédicat " +"donné." #: ../Doc/howto/functional.rst:844 msgid "" @@ -938,6 +1385,9 @@ msgid "" "the opposite of :func:`filter`, returning all elements for which the " "predicate returns false::" msgstr "" +":func:`itertools.filterfalse(predicate, iter) ` est " +"l'opposé de :func:`filter` et renvoie tous les éléments pour lesquels le " +"prédicat est faux ::" #: ../Doc/howto/functional.rst:851 msgid "" @@ -945,6 +1395,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) ` renvoie " +"les éléments de l'itérateur tant que ceux-ci vérifient le prédicat. Dès lors " +"que le prédicat renvoie faux, l'itération s'arrête. ::" #: ../Doc/howto/functional.rst:864 msgid "" @@ -952,6 +1405,9 @@ msgid "" "elements while the predicate returns true, and then returns the rest of the " "iterable's results. ::" msgstr "" +":func:`itertools.dropwhile(predicate, iter) ` supprime " +"des éléments tant que le prédicat renvoie vrai puis renvoie le reste des " +"éléments de l'itérable. ::" #: ../Doc/howto/functional.rst:874 msgid "" @@ -960,10 +1416,14 @@ msgid "" "corresponding element of *selectors* is true, stopping whenever either one " "is exhausted::" msgstr "" +":func:`itertools.compress(data, selectors) ` prend un " +"itérateur *data* et un itérateur *selectors* et renvoie les éléments de " +"*data* pour lesquels l'élément correspondant de *selectors* évalue à vrai. " +"L'itération s'arrête lorsque l'un des deux itérateurs est épuisé ::" #: ../Doc/howto/functional.rst:883 msgid "Combinatoric functions" -msgstr "" +msgstr "Fonctions combinatoires" #: ../Doc/howto/functional.rst:885 msgid "" @@ -971,6 +1431,9 @@ msgid "" "returns an iterator giving all possible *r*-tuple combinations of the " "elements contained in *iterable*. ::" msgstr "" +":func:`itertools.combinations(iterable, r) ` renvoie " +"un itérateur qui produit toutes les combinaisons possibles de *r*-uplets des " +"éléments de *iterable*. ::" #: ../Doc/howto/functional.rst:900 msgid "" @@ -980,24 +1443,38 @@ msgid "" "permutations(iterable, r=None) `, removes this " "constraint on the order, returning all possible arrangements of length *r*::" msgstr "" +"Les éléments de chaque tuple sont ordonnés dans le même ordre que leur " +"apparition dans *iterable*. Ainsi, dans les exemples ci-dessus, le nombre 1 " +"se trouve toujours avant 2, 3, 4 ou 5. La fonction :func:`itertools." +"permutations(iterable, r=None) ` supprime la " +"contrainte sur l'ordre et renvoie 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 vous ne spécifiez pas de valeur pour *r*, la longueur de l'itérable est " +"utilisée par défaut, c'est-à-dire que toutes les permutations de la séquence " +"sont renvoyées." #: ../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 "" +"Notez que ces fonctions génèrent toutes les combinaisons possibles en se " +"basant sur la position des éléments et ne requièrent pas que les éléments de " +"*iterable* soient uniques ::" #: ../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 triplet ``('a', 'a', 'b')`` apparaît deux fois mais les deux chaînes de " +"caractères ``'a'`` proviennent de deux positions différentes." #: ../Doc/howto/functional.rst:932 msgid "" @@ -1007,10 +1484,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) " +"` assouplit une autre contrainte : " +"les éléments peuvent être répétés au sein du même n-uplet. Il s'agit d'un " +"tirage avec remise : le premier élément sélectionné pour chaque n-uplet est " +"replacé dans la séquence avant le tirage du deuxième. ::" #: ../Doc/howto/functional.rst:947 msgid "Grouping elements" -msgstr "" +msgstr "Grouper les éléments" #: ../Doc/howto/functional.rst:949 msgid "" @@ -1020,6 +1502,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 que allons voir, :func:`itertools.groupby(iter, " +"key_func=None) ` est la plus complexe. ``key_func(elem)`` " +"est une fonction qui produit une clé pour chaque élément renvoyé par " +"l'itérable. Si vous ne spécifiez pas de fonction *key*, alors celle-ci sera " +"l'identité par défaut (c'est-à-dire que la clé d'un élément sera lui-même)." #: ../Doc/howto/functional.rst:954 msgid "" @@ -1027,6 +1514,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` rassemble tous éléments consécutifs de l'itérable " +"sous-jacent qui ont la même clé et renvoie un flux de pairs contenant la clé " +"et un itérateur produisant la liste des éléments pour cette clé." #: ../Doc/howto/functional.rst:982 msgid "" @@ -1035,10 +1525,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` fait l'hypothèse que le contenu de l'itérable " +"sous-jacent est d'ores et déjà ordonné en fonction de la clé. Notez que les " +"itérateurs générés utilisent également l'itérable sous-jacent. Vous devrez " +"donc consommer l'intégralité des résultats du premier itérateur renvoyé " +"avant de récupérer le deuxième itérateur et la clé correspondante." #: ../Doc/howto/functional.rst:989 msgid "The functools module" -msgstr "" +msgstr "Le module *functools*" #: ../Doc/howto/functional.rst:991 msgid "" @@ -1047,6 +1542,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` introduit par Python 2.5 contient diverses " +"fonctions d'ordre supérieur. Une **fonction d'ordre supérieur** prend une ou " +"plusieurs fonctions en entrée et renvoie une fonction. L'outil le plus " +"important de ce module est la fonction :func:`functools.partial`." #: ../Doc/howto/functional.rst:996 msgid "" @@ -1057,6 +1556,13 @@ msgid "" "filling in a value for one of ``f()``'s parameters. This is called " "\"partial function application\"." msgstr "" +"En programmant dans un style fonctionnel, il est courant de vouloir " +"construire des variantes de fonctions existantes dont certaines des " +"paramètres sont préremplis. Par exemple, considérons une fonction Python " +"``f(a, b, c)``. Il peut arriver de vouloir une nouvelle fonction ``g(b, c)`` " +"équivalente à ``f(1, b, c)``, c'est-à-dire fixer le premier paramètre de " +"``f()``. La fonction ``g()`` est une appelée « application partielle » de " +"``f()``." #: ../Doc/howto/functional.rst:1002 msgid "" @@ -1065,6 +1571,9 @@ 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 en argument ``(fonction, " +"arg1, arg2, ..., kwarg1=value1, kwarg2=value2, ...)``. Un appel à l'objet " +"ainsi créé invoque la fonction ``fonction`` avec les arguments spécifiés." #: ../Doc/howto/functional.rst:1007 msgid "Here's a small but realistic example::" @@ -1084,6 +1593,17 @@ 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]) ` " +"applique une opération cumulative à tous les éléments d'un itérable et ne " +"peut donc être appliquée à des itérables infinis. *func* doit être une " +"fonction qui prend deux éléments 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)``. Elle extrait ensuite le troisième " +"élément C et calcule ``func(func(A, B), C)`` puis combine ce résultat avec " +"le quatrième élément renvoyé etc. jusqu'à épuisement de l'itérable. Une " +"exception :exc:`TypeError` est levée si l'itérable ne renvoie aucune valeur. " +"La valeur initiale *initial_value*, si spécifiée, est utilisée comme point " +"de départ et le premier calcul est alors ``func(inital_value, A)``. ::" #: ../Doc/howto/functional.rst:1043 msgid "" @@ -1091,12 +1611,19 @@ 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 combinez :func:`operator.add` avec :func:`functools.reduce`, vous " +"allez additionner tous les éléments de l'itérable. Ce cas est suffisamment " +"courant pour qu'il existe une fonction native :func:`sum` qui lui est " +"équivalent :" #: ../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 "" +"Cependant, il peut être plus lisible dans de nombreuses situations " +"impliquant :func:`functools.reduce` de simplement écrire la boucle :keyword:" +"`for` ::" #: ../Doc/howto/functional.rst:1067 msgid "" @@ -1105,10 +1632,15 @@ msgid "" "of returning only the final result, :func:`accumulate` returns an iterator " "that also yields each partial result::" msgstr "" +":func:`itertools.accumulate(iterable, func=operator.add) ` est une fonction similaire qui réalise le même calcul mais, " +"plutôt que de renvoyer seulement le résultat final, :func:`accumulate` " +"renvoie un itérateur qui génère la séquence de tous les résultats " +"intermédiaires ::" #: ../Doc/howto/functional.rst:1080 msgid "The operator module" -msgstr "" +msgstr "Le module *operator*" #: ../Doc/howto/functional.rst:1082 msgid "" @@ -1117,53 +1649,68 @@ msgid "" "useful in functional-style code because they save you from writing trivial " "functions that perform a single operation." msgstr "" +"Le module :mod:`operator` mentionné précédemment contient un ensemble de " +"fonctions reproduisant les opérateurs de Python. Ces fonctions sont souvent " +"utiles en programmation fonctionnelle car elles permettent de ne pas avoir à " +"écrire des fonctions triviales qui ne réalisent qu'une seule opération." #: ../Doc/howto/functional.rst:1087 msgid "Some of the functions in this module are:" -msgstr "" +msgstr "Voici quelques fonctions de ce module :" #: ../Doc/howto/functional.rst:1089 msgid "" "Math operations: ``add()``, ``sub()``, ``mul()``, ``floordiv()``, " "``abs()``, ..." msgstr "" +"Les opérations mathématiques : ``add()``, ``sub()``, ``mul()``, " +"``floordiv()``, ``abs()``, ..." #: ../Doc/howto/functional.rst:1090 msgid "Logical operations: ``not_()``, ``truth()``." -msgstr "" +msgstr "Les opérations logiques : ``not_()``, ``truth()``." #: ../Doc/howto/functional.rst:1091 msgid "Bitwise operations: ``and_()``, ``or_()``, ``invert()``." -msgstr "" +msgstr "Les opérations bit à bit : ``and_()``, ``or_()``, ``invert()``." #: ../Doc/howto/functional.rst:1092 msgid "" "Comparisons: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, and ``ge()``." msgstr "" +"Les comparaisons : ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, et " +"``ge()``." #: ../Doc/howto/functional.rst:1093 msgid "Object identity: ``is_()``, ``is_not()``." -msgstr "" +msgstr "L'identification des objets : ``is_()``, ``is_not()``." #: ../Doc/howto/functional.rst:1095 msgid "Consult the operator module's documentation for a complete list." msgstr "" +"Veuillez vous référer à la documentation du module *operator* pour une liste " +"complète." #: ../Doc/howto/functional.rst:1099 msgid "Small functions and the lambda expression" -msgstr "" +msgstr "Expressions lambda et fonctions courtes" #: ../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 "" +"Dans un style de programmation fonctionnel, il est courant d'avoir besoin de " +"petites fonctions utilisées comme prédicats ou pour combiner des éléments " +"d'une façon ou d'une autre." #: ../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 "" +"S'il existe une fonction native Python ou une fonction d'un module qui " +"convient, vous n'avez pas besoin de définir de nouvelle fonction ::" #: ../Doc/howto/functional.rst:1110 msgid "" @@ -1173,18 +1720,27 @@ msgid "" "parameters, and creates an anonymous function that returns the value of the " "expression::" msgstr "" +"Si la fonction dont vous avez besoin n'existe pas, vous devez l'écrire. Une " +"façon d'écrire des fonctions courtes consiste à utiliser les expressions :" +"keyword:`lambda`. ``lambda`` prend plusieurs paramètres et une expression " +"combinant ces derniers afin de créer une fonction anonyme qui renvoie la " +"valeur 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 "" +"Une autre façon de faire est de simplement utiliser l'instruction ``def`` " +"afin de définir une fonction de la manière habituelle ::" #: ../Doc/howto/functional.rst:1128 msgid "" "Which alternative is preferable? That's a style question; my usual course " "is to avoid using ``lambda``." msgstr "" +"La méthode à préférer est une question de style, en général je préfère " +"éviter l'utilisation de ``lambda``." #: ../Doc/howto/functional.rst:1131 msgid "" @@ -1195,6 +1751,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 "" +"Une des raisons pour cela est que ``lambda`` ne peut pas définir toutes les " +"fonctions. Le résultat doit pouvoir se calculer en une seule expression, ce " +"qui signifie qu'il est impossible d'avoir des comparaisons ``if ... elif ... " +"else`` à plusieurs branches ou des structures ``try ... except``. Si vous " +"essayez de trop en faire dans une expression ``lambda``, vous finirez avec " +"une expression illisible. Par exemple, pouvez-vous dire du premier coup " +"d’œil ce que fait le code ci-dessous ? ::" #: ../Doc/howto/functional.rst:1141 msgid "" @@ -1202,58 +1765,73 @@ msgid "" "figure out what's going on. Using a short nested ``def`` statements makes " "things a little bit better::" msgstr "" +"Vous pouvez sûrement comprendre ce que fait ce code mais cela prend du temps " +"de démêler l'expression pour y voir plus clair. Une clause ``def`` concise " +"améliore la situation ::" #: ../Doc/howto/functional.rst:1151 msgid "But it would be best of all if I had simply used a ``for`` loop::" msgstr "" +"Toutefois l'idéal serait de simplement se contenter d'une boucle ``for`` ::" #: ../Doc/howto/functional.rst:1157 msgid "Or the :func:`sum` built-in and a generator expression::" msgstr "" +"Ou de la fonction native :func:`sum` et d'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 "" +"Les boucles ``for`` sont souvent plus lisibles que la fonction :func:" +"`functools.reduce`." #: ../Doc/howto/functional.rst:1163 msgid "" "Fredrik Lundh once suggested the following set of rules for refactoring uses " "of ``lambda``:" msgstr "" +"Frederik Lundh a suggéré quelques règles pour le réusinage de code " +"impliquant les expressions ``lambda`` :" #: ../Doc/howto/functional.rst:1166 msgid "Write a lambda function." -msgstr "" +msgstr "Écrire une fonction lambda." #: ../Doc/howto/functional.rst:1167 msgid "Write a comment explaining what the heck that lambda does." msgstr "" +"Écrire un commentaire qui explique ce que fait cette satanée fonction 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 "" +"Scruter le commentaire pendant quelques temps et réfléchir à un nom qui " +"synthétise son essence." #: ../Doc/howto/functional.rst:1170 msgid "Convert the lambda to a def statement, using that name." msgstr "" +"Réécrire la fonction lambda en une définition *def* en utilisant ce nom." #: ../Doc/howto/functional.rst:1171 msgid "Remove the comment." -msgstr "" +msgstr "Effacer 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 vous êtes libre de ne pas être d'accord et " +"de ne pas préférer ce style sans lambda." #: ../Doc/howto/functional.rst:1178 msgid "Revision History and Acknowledgements" -msgstr "" +msgstr "Historique des modifications et remerciements" #: ../Doc/howto/functional.rst:1180 msgid "" @@ -1262,31 +1840,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 souhaiterait remercier les personnes suivantes pour leurs " +"suggestions, leurs corrections et leur aide sur les premières versions de " +"cet article : Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim " +"Jewett, Mike Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake " +"Winton." #: ../Doc/howto/functional.rst:1185 msgid "Version 0.1: posted June 30 2006." -msgstr "" +msgstr "Version 0.1 : publié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 : publiée le 1er juillet 2006. Correction orthographique." #: ../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 : publiée le 10 juillet 2006. Fusion des sections *genexp* et " +"*listcomp*. Correction orthographique." #: ../Doc/howto/functional.rst:1192 msgid "" "Version 0.21: Added more references suggested on the tutor mailing list." msgstr "" +"Version 0.21 : ajout de plusieurs références suggérées sur la liste de " +"diffusion *tutor*." #: ../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`` écrite par " +"Collin Winter ; ajout d'une courte section sur le module ``operator`` ; " +"quelques autres modifications." #: ../Doc/howto/functional.rst:1199 msgid "References" @@ -1294,7 +1884,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 +1896,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. Disponible à l'adresse https://" +"mitpress.mit.edu/sicp/. Ce livre est un classique en informatique. Les " +"chapitres 2 et 3 présentent l'utilisation des séquences et des flux pour " +"organiser le flot de données dans un programme. Les exemples du livre " +"utilisent le langage Scheme mais la plupart des approches décrites dans ces " +"chapitres s'appliquent au style fonctionnel de Python." #: ../Doc/howto/functional.rst:1212 msgid "" @@ -1313,25 +1910,33 @@ msgid "" "functional programming that uses Java examples and has a lengthy historical " "introduction." msgstr "" +"http://www.defmacro.org/ramblings/fp.html : une présentation générale à la " +"programmation fonctionnelle avec une longue introduction historique et des " +"exemples en Java." #: ../Doc/howto/functional.rst:1215 msgid "" "https://en.wikipedia.org/wiki/Functional_programming: General Wikipedia " "entry describing functional programming." msgstr "" +"https://fr.wikipedia.org/wiki/Programmation_fonctionnelle : l'entrée " +"Wikipédia qui décrit la programmation fonctionnelle." #: ../Doc/howto/functional.rst:1218 msgid "https://en.wikipedia.org/wiki/Coroutine: Entry for coroutines." msgstr "" +"https://fr.wikipedia.org/wiki/Coroutine : l'entrée pour les coroutines." #: ../Doc/howto/functional.rst:1220 msgid "" "https://en.wikipedia.org/wiki/Currying: Entry for the concept of currying." msgstr "" +"https://fr.wikipedia.org/wiki/Curryfication : l'entrée pour de la concept de " +"la curryfication (création d'applications partielles)." #: ../Doc/howto/functional.rst:1223 msgid "Python-specific" -msgstr "" +msgstr "Spécifique à Python" #: ../Doc/howto/functional.rst:1225 msgid "" @@ -1340,6 +1945,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` présente l'utilisation de la " +"programmation fonctionnelle pour le traitement de texte dans la section « " +"Utilisation des fonctions d'ordre supérieur pour le traitement de texte »." #: ../Doc/howto/functional.rst:1230 msgid "" @@ -1349,29 +1958,37 @@ msgid "" "developerworks/linux/library/l-prog2/index.html>`__, and `part 3 `__," msgstr "" +"Mertz a également écrit une série de 3 articles (en anglais) sur la " +"programmation fonctionnelle pour le site de IBM *DeveloperWorks*, voir la " +"`partie 1 `__, la `partie 2 `__ et la `partie 3 `__." #: ../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 du module :mod:`itertools`." #: ../Doc/howto/functional.rst:1242 msgid "Documentation for the :mod:`functools` module." -msgstr "" +msgstr "Documentation du module :mod:`functools`." #: ../Doc/howto/functional.rst:1244 msgid "Documentation for the :mod:`operator` module." -msgstr "" +msgstr "Documentation du 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 des générateurs en Python 2.5."