# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" "PO-Revision-Date: 2022-05-12 09:39+0200\n" "Last-Translator: Jean Abou Samra \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" "X-Generator: Poedit 3.0.1\n" #: howto/functional.rst:3 msgid "Functional Programming HOWTO" msgstr "Guide pratique : programmation fonctionnelle" #: howto/functional.rst:0 msgid "Author" msgstr "Auteur" #: howto/functional.rst:5 msgid "A. M. Kuchling" msgstr "A. M. Kuchling" #: howto/functional.rst:0 msgid "Release" msgstr "Version" #: howto/functional.rst:6 msgid "0.32" msgstr "0.32" #: howto/functional.rst:8 msgid "" "In this document, we'll take a tour of Python's features suitable for " "implementing programs in a functional style. After an introduction to the " "concepts of functional programming, we'll look at language features such as :" "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`." #: howto/functional.rst:16 msgid "Introduction" msgstr "Introduction" #: howto/functional.rst:18 msgid "" "This section explains the basic concept of functional programming; if you're " "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`." #: 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 :" # Énumération #: howto/functional.rst:24 msgid "" "Most programming languages are **procedural**: programs are lists of " "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 ;" # Énumération #: howto/functional.rst:28 msgid "" "In **declarative** languages, you write a specification that describes the " "problem to be solved, and the language implementation figures out how to " "perform the computation efficiently. SQL is the declarative language you're " "most likely to be familiar with; a SQL query describes the data set you want " "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. ;" # Énumération #: howto/functional.rst:35 msgid "" "**Object-oriented** programs manipulate collections of objects. Objects " "have internal state and support methods that query or modify this internal " "state in some way. Smalltalk and Java are object-oriented languages. C++ " "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 ;" # Énumération #: howto/functional.rst:41 msgid "" "**Functional** programming decomposes a problem into a set of functions. " "Ideally, functions only take inputs and produce outputs, and don't have any " "internal state that affects the output produced for a given input. Well-" "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 ;" #: howto/functional.rst:47 msgid "" "The designers of some computer languages choose to emphasize one particular " "approach to programming. This often makes it difficult to write programs " "that use a different approach. Other languages are multi-paradigm languages " "that support several different approaches. Lisp, C++, and Python are multi-" "paradigm; you can write programs or libraries that are largely procedural, " "object-oriented, or functional in all of these languages. In a large " "program, different sections might be written using different approaches; the " "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 langages ; 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." #: howto/functional.rst:58 msgid "" "In a functional program, input flows through a set of functions. Each " "function operates on its input and produces some output. Functional style " "discourages functions with side effects that modify internal state or make " "other changes that aren't visible in the function's return value. Functions " "that have no side effects at all are called **purely functional**. Avoiding " "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." #: howto/functional.rst:66 msgid "" "Some languages are very strict about purity and don't even have assignment " "statements such as ``a=3`` or ``c = a + b``, but it's difficult to avoid all " "side effects, such as printing to the screen or writing to a disk file. " "Another example is a call to the :func:`print` or :func:`time.sleep` " "function, neither of which returns a useful value. Both are called only 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. Pour prendre un " "autre 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 ou mettre en pause " "l'exécution du programme)." #: howto/functional.rst:73 msgid "" "Python programs written in functional style usually won't go to the extreme " "of avoiding all I/O or all assignments; instead, they'll provide a " "functional-appearing interface but will use non-functional features " "internally. For example, the implementation of a function will still use " "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." #: howto/functional.rst:79 msgid "" "Functional programming can be considered the opposite of object-oriented " "programming. Objects are little capsules containing some internal state " "along with a collection of method calls that let you modify this state, and " "programs consist of making the right set of state changes. Functional " "programming wants to avoid state changes as much as possible and works with " "data flowing between functions. In Python you might combine the two " "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.)." #: howto/functional.rst:88 msgid "" "Functional design may seem like an odd constraint to work under. Why should " "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 :" # Énumération #: howto/functional.rst:92 msgid "Formal provability." msgstr "preuves formelles ;" # Énumération #: howto/functional.rst:93 msgid "Modularity." msgstr "modularité ;" # Énumération #: howto/functional.rst:94 msgid "Composability." msgstr "composabilité ;" # Énumération #: howto/functional.rst:95 msgid "Ease of debugging and testing." msgstr "facilité de débogage et de test." #: howto/functional.rst:99 msgid "Formal provability" msgstr "Preuves formelles" #: howto/functional.rst:101 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." #: howto/functional.rst:104 msgid "" "For a long time researchers have been interested in finding ways to " "mathematically prove programs correct. This is different from testing a " "program on numerous inputs and concluding that its output is usually " "correct, or reading a program's source code and concluding that the code " "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." #: howto/functional.rst:111 msgid "" "The technique used to prove programs correct is to write down " "**invariants**, properties of the input data and of the program's variables " "that are always true. For each line of code, you then show that if " "invariants X and Y are true **before** the line is executed, the slightly " "different invariants X' and Y' are true **after** the line is executed. " "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." #: howto/functional.rst:119 msgid "" "Functional programming's avoidance of assignments arose because assignments " "are difficult to handle with this technique; assignments can break " "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." #: howto/functional.rst:124 msgid "" "Unfortunately, proving programs correct is largely impractical and not " "relevant to Python software. Even trivial programs require proofs that are " "several pages long; the proof of correctness for a moderately complicated " "program would be enormous, and few or none of the programs you use daily " "(the Python interpreter, your XML parser, your web browser) could be proven " "correct. Even if you wrote down or generated a proof, there would then be " "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." #: howto/functional.rst:135 msgid "Modularity" msgstr "Modularité" #: howto/functional.rst:137 msgid "" "A more practical benefit of functional programming is that it forces you to " "break apart your problem into small pieces. Programs are more modular as a " "result. It's easier to specify and write a small function that does one " "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." #: howto/functional.rst:145 msgid "Ease of debugging and testing" msgstr "Facilité de débogage et de test" #: howto/functional.rst:147 msgid "Testing and debugging a functional-style program is easier." msgstr "Tester et déboguer un programme fonctionnel est plus facile." #: howto/functional.rst:149 msgid "" "Debugging is simplified because functions are generally small and clearly " "specified. When a program doesn't work, each function is an interface point " "where you can check that the data are correct. You can look at the " "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." #: howto/functional.rst:154 msgid "" "Testing is easier because each function is a potential subject for a unit " "test. Functions don't depend on system state that needs to be replicated " "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." #: howto/functional.rst:161 msgid "Composability" msgstr "Composabilité" #: howto/functional.rst:163 msgid "" "As you work on a functional-style program, you'll write a number of " "functions with varying inputs and outputs. Some of these functions will be " "unavoidably specialized to a particular application, but others will be " "useful in a wide variety of programs. For example, a function that takes a " "directory path and returns all the XML files in the directory, or a function " "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 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." #: howto/functional.rst:170 msgid "" "Over time you'll form a personal library of utilities. Often you'll " "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." #: howto/functional.rst:178 msgid "Iterators" msgstr "Itérateurs" #: howto/functional.rst:180 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." #: howto/functional.rst:183 msgid "" "An iterator is an object representing a stream of data; this object returns " "the data one element at a time. A Python iterator must support a method " "called :meth:`~iterator.__next__` that takes no arguments and always returns " "the next element of the stream. If there are no more elements in the " "stream, :meth:`~iterator.__next__` must raise the :exc:`StopIteration` " "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." #: howto/functional.rst:191 msgid "" "The built-in :func:`iter` function takes an arbitrary object and tries to " "return an iterator that will return the object's contents or elements, " "raising :exc:`TypeError` if the object doesn't support iteration. Several " "of Python's built-in data types support iteration, the most common being " "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." #: howto/functional.rst:198 msgid "You can experiment with the iteration interface manually:" msgstr "Vous pouvez expérimenter avec l'interface d'itération manuellement :" #: howto/functional.rst:216 msgid "" "Python expects iterable objects in several different contexts, the most " "important being the :keyword:`for` statement. In the statement ``for X in " "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 ::" #: howto/functional.rst:228 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 *n*-uplets en " "appelant les constructeurs respectifs :func:`list` et :func:`tuple` :" #: howto/functional.rst:237 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 :" #: howto/functional.rst:246 msgid "" "Built-in functions such as :func:`max` and :func:`min` can take a single " "iterator argument and will return the largest or smallest element. The " "``\"in\"`` and ``\"not in\"`` operators also support iterators: ``X in " "iterator`` is true if X is found in the stream returned by the iterator. " "You'll run into obvious problems if the iterator is infinite; :func:`max`, :" "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 petit " "é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." #: howto/functional.rst:254 msgid "" "Note that you can only go forward in an iterator; there's no way to get the " "previous element, reset the iterator, or make a copy of it. Iterator " "objects can optionally provide these additional capabilities, but the " "iterator protocol only specifies the :meth:`~iterator.__next__` method. " "Functions may therefore consume all of the iterator's output, and if you " "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." #: howto/functional.rst:264 msgid "Data Types That Support Iterators" msgstr "Types de données itérables" #: howto/functional.rst:266 msgid "" "We've already seen how lists and tuples support iterators. In fact, any " "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 *n*-uplets 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." #: howto/functional.rst:270 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 ::" #: howto/functional.rst:290 msgid "" "Note that starting with Python 3.7, dictionary iteration order is guaranteed " "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." #: howto/functional.rst:294 msgid "" "Applying :func:`iter` to a dictionary always loops over the keys, but " "dictionaries have methods that return other iterators. If you want to " "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." #: howto/functional.rst:300 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)`` :" #: howto/functional.rst:307 msgid "" "Files also support iteration by calling the :meth:`~io.TextIOBase.readline` " "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 ::" #: howto/functional.rst:315 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 ::" #: howto/functional.rst:331 msgid "Generator expressions and list comprehensions" msgstr "Expressions génératrices et compréhension de listes" #: howto/functional.rst:333 msgid "" "Two common operations on an iterator's output are 1) performing some " "operation for every element, 2) selecting a subset of elements that meet " "some condition. For example, given a list of strings, you might want to " "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." #: howto/functional.rst:339 msgid "" "List comprehensions and generator expressions (short form: \"listcomps\" and " "\"genexps\") are a concise notation for such operations, borrowed from the " "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 des façons " "concises 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 initiaux et finaux d'un flux de chaînes " "de caractères à l'aide du code suivant ::" #: howto/functional.rst:352 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`` » ::" #: howto/functional.rst:357 msgid "" "With a list comprehension, you get back a Python list; ``stripped_list`` is " "a list containing the resulting lines, not an iterator. Generator " "expressions return an iterator that computes the values as necessary, not " "needing to materialize all the values at once. This means that list " "comprehensions aren't useful if you're working with iterators that return an " "infinite stream or a very large amount of data. Generator expressions are " "preferable in these situations." msgstr "" "La compréhension de liste renvoie 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." #: howto/functional.rst:364 msgid "" "Generator expressions are surrounded by parentheses (\"()\") and list " "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 ::" #: howto/functional.rst:378 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 manière, utilisez " "juste des crochets à la place des parenthèses." #: howto/functional.rst:381 msgid "" "The elements of the generated output will be the successive values of " "``expression``. The ``if`` clauses are all optional; if present, " "``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`` n'est " "évaluée et ajoutée au résultat que si ``condition`` est vérifiée." #: howto/functional.rst:385 msgid "" "Generator expressions always have to be written inside parentheses, but the " "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 ::" #: howto/functional.rst:391 msgid "" "The ``for...in`` clauses contain the sequences to be iterated over. The " "sequences do not have to be the same length, because they are iterated over " "from left to right, **not** in parallel. For each element in ``sequence1``, " "``sequence2`` is looped over from the beginning. ``sequence3`` is then " "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``." #: howto/functional.rst:397 msgid "" "To put it another way, a list comprehension or generator expression is " "equivalent to the following Python code::" msgstr "" "Autrement dit, une compréhension de liste ou une expression génératrice est " "équivalente au code Python ci-dessous ::" #: howto/functional.rst:414 msgid "" "This means that when there are multiple ``for...in`` clauses but no ``if`` " "clauses, the length of the resulting output will be equal to the product of " "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 :" #: howto/functional.rst:426 msgid "" "To avoid introducing an ambiguity into Python's grammar, if ``expression`` " "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 de ne pas 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 ::" #: howto/functional.rst:437 msgid "Generators" msgstr "Générateurs" #: howto/functional.rst:439 msgid "" "Generators are a special class of functions that simplify the task of " "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." #: howto/functional.rst:443 msgid "" "You're doubtless familiar with how regular function calls work in Python or " "C. When you call a function, it gets a private namespace where its local " "variables are created. When the function reaches a ``return`` statement, " "the local variables are destroyed and the value is returned to the caller. " "A later call to the same function creates a new private namespace and a " "fresh set of local variables. But, what if the local variables weren't " "thrown away on exiting a function? What if you could later resume the " "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 nommage 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 nommage 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." #: howto/functional.rst:452 msgid "Here's the simplest example of a generator function:" msgstr "Voici un exemple simple de fonction génératrice :" #: howto/functional.rst:458 msgid "" "Any function containing a :keyword:`yield` keyword is a generator function; " "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é et " "prend en compte cette particularité de la fonction." #: howto/functional.rst:462 msgid "" "When you call a generator function, it doesn't return a single value; " "instead it returns a generator object that supports the iterator protocol. " "On executing the ``yield`` expression, the generator outputs the value of " "``i``, similar to a ``return`` statement. The big difference between " "``yield`` and a ``return`` statement is that on reaching a ``yield`` the " "generator's state of execution is suspended and local variables are " "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 reprend son exécution." #: howto/functional.rst:471 msgid "Here's a sample usage of the ``generate_ints()`` generator:" msgstr "Voici un exemple d'utilisation du générateur ``generate_ints()`` :" #: howto/functional.rst:488 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)``." #: howto/functional.rst:491 msgid "" "Inside a generator function, ``return value`` causes " "``StopIteration(value)`` to be raised from the :meth:`~generator.__next__` " "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, une instruction ``return value`` entraîne la " "levée d'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." #: howto/functional.rst:496 msgid "" "You could achieve the effect of generators manually by writing your own " "class and storing all the local variables of the generator as instance " "variables. For example, returning a list of integers could be done by " "setting ``self.count`` to 0, and having the :meth:`~iterator.__next__` " "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." #: howto/functional.rst:504 msgid "" "The test suite included with Python's library, :source:`Lib/test/" "test_generators.py`, contains a number of more interesting examples. Here's " "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. ::" #: howto/functional.rst:520 msgid "" "Two other examples in ``test_generators.py`` produce solutions for the N-" "Queens problem (placing N queens on an NxN chess board so that no queen " "threatens another) and the Knight's Tour (finding a route that takes a " "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)." #: howto/functional.rst:528 msgid "Passing values into a generator" msgstr "Transmettre des valeurs au générateur" #: howto/functional.rst:530 msgid "" "In Python 2.4 and earlier, generators only produced output. Once a " "generator's code was invoked to create an iterator, there was no way to pass " "any new information into the function when its execution is resumed. You " "could hack together this ability by making the generator look at a global " "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 à obtenir 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." #: howto/functional.rst:537 msgid "" "In Python 2.5 there's a simple way to pass values into a generator. :keyword:" "`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 ::" #: howto/functional.rst:543 msgid "" "I recommend that you **always** put parentheses around a ``yield`` " "expression when you're doing something with the returned value, as in the " "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, nous vous recommandons 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." #: howto/functional.rst:548 msgid "" "(:pep:`342` explains the exact rules, which are that a ``yield``-expression " "must always be parenthesized except when it occurs at the top-level " "expression on the right-hand side of an assignment. This means you can " "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``.)" #: howto/functional.rst:554 msgid "" "Values are sent into a generator by calling its :meth:`send(value) " "` method. This method resumes the generator's code and the " "``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``." #: howto/functional.rst:559 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." #: howto/functional.rst:574 msgid "And here's an example of changing the counter:" msgstr "Et voici comment il est possible de modifier le compteur :" #: howto/functional.rst:591 msgid "" "Because ``yield`` will often be returning ``None``, you should always check " "for this case. Don't just use its value in expressions unless you're sure " "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." #: howto/functional.rst:596 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 :" # Énumération #: howto/functional.rst:599 msgid "" ":meth:`throw(value) ` is used to raise an exception inside " "the generator; the exception is raised by the ``yield`` expression where the " "generator's execution is paused." msgstr "" ":meth:`throw(value) ` 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." #: howto/functional.rst:603 msgid "" ":meth:`~generator.close` raises a :exc:`GeneratorExit` exception inside the " "generator to terminate the iteration. On receiving this exception, the " "generator's code must either raise :exc:`GeneratorExit` or :exc:" "`StopIteration`; catching the exception and doing anything else is illegal " "and will trigger a :exc:`RuntimeError`. :meth:`~generator.close` will also " "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 collecte le générateur, il appelle sa méthode :" "meth:`~generator.close`." #: howto/functional.rst:611 msgid "" "If you need to run cleanup code when a :exc:`GeneratorExit` occurs, I " "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`, nous vous suggérons d'utiliser une structure ``try: ... " "finally`` plutôt que d'attraper :exc:`GeneratorExit`." #: howto/functional.rst:614 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." #: howto/functional.rst:617 msgid "" "Generators also become **coroutines**, a more generalized form of " "subroutines. Subroutines are entered at one point and exited at another " "point (the top of the function, and a ``return`` statement), but coroutines " "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``)." #: howto/functional.rst:624 msgid "Built-in functions" msgstr "Fonctions natives" #: howto/functional.rst:626 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." #: howto/functional.rst:628 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 :" #: howto/functional.rst:640 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" #: howto/functional.rst:632 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]), ...``." #: howto/functional.rst:642 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." #: howto/functional.rst:644 msgid "" ":func:`filter(predicate, iter) ` returns an iterator over all the " "sequence elements that meet a certain condition, and is similarly duplicated " "by list comprehensions. A **predicate** is a function that returns the " "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." #: howto/functional.rst:657 msgid "This can also be written as a list comprehension:" msgstr "Cela peut se réécrire sous la forme d'une compréhension de liste :" #: howto/functional.rst:663 msgid "" ":func:`enumerate(iter, start=0) ` counts off the elements in the " "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 ::" #: howto/functional.rst:673 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ée lorsque l'on souhaite boucler sur une " "liste tout en listant les indices pour lesquels une certaine condition est " "vérifiée ::" #: howto/functional.rst:681 msgid "" ":func:`sorted(iterable, key=None, reverse=False) ` collects all the " "elements of the iterable into a list, sorts the list, and returns the sorted " "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. ::" #: howto/functional.rst:696 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`.)" #: howto/functional.rst:699 msgid "" "The :func:`any(iter) ` and :func:`all(iter) ` 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) ` 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 :" #: howto/functional.rst:718 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 ::" #: howto/functional.rst:724 msgid "" "It doesn't construct an in-memory list and exhaust all the input iterators " "before returning; instead tuples are constructed and returned only if " "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 *n*-uplets sont " "construits et renvoyés au fur et à mesure (il s'agit techniquement parlant " "d'un comportement d'`évaluation paresseuse `__)." #: howto/functional.rst:729 msgid "" "This iterator is intended to be used with iterables that are all of the same " "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 a la même longueur que le " "plus court des itérables. ::" #: howto/functional.rst:736 msgid "" "You should avoid doing this, though, because an element may be taken from " "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é." #: howto/functional.rst:742 msgid "The itertools module" msgstr "Le module *itertools*" #: howto/functional.rst:744 #, fuzzy msgid "" "The :mod:`itertools` module contains a number of commonly used iterators as " "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." #: howto/functional.rst:748 msgid "The module's functions fall into a few broad classes:" msgstr "Les fonctions du module se divisent en quelques grandes catégories :" # Énumération #: howto/functional.rst:750 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 ;" # Énumération #: howto/functional.rst:751 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 ;" # Énumération #: howto/functional.rst:752 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 ;" # Énumération #: howto/functional.rst:753 msgid "A function for grouping an iterator's output." msgstr "une fonction qui permet de grouper la sortie d'un itérateur." #: howto/functional.rst:756 msgid "Creating new iterators" msgstr "Créer de nouveaux itérateurs" #: howto/functional.rst:758 msgid "" ":func:`itertools.count(start, step) ` returns an infinite " "stream of evenly spaced values. You can optionally supply the starting " "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) ::" #: howto/functional.rst:769 msgid "" ":func:`itertools.cycle(iter) ` saves a copy of the contents " "of a provided iterable and returns a new iterator that returns its elements " "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. ::" #: howto/functional.rst:776 msgid "" ":func:`itertools.repeat(elem, [n]) ` returns the provided " "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é. ::" #: howto/functional.rst:784 msgid "" ":func:`itertools.chain(iterA, iterB, ...) ` takes an " "arbitrary number of iterables as input, and returns all the elements of the " "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. ::" #: howto/functional.rst:792 msgid "" ":func:`itertools.islice(iter, [start], stop, [step]) ` " "returns a stream that's a slice of the iterator. With a single *stop* " "argument, it will return the first *stop* elements. If you supply a " "starting index, you'll get *stop-start* elements, and if you supply a value " "for *step*, elements will be skipped accordingly. Unlike Python's string " "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 ; utilisez *step* pour spécifier une " "valeur de pas. 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). ::" #: howto/functional.rst:806 msgid "" ":func:`itertools.tee(iter, [n]) ` replicates an iterator; it " "returns *n* independent iterators that will all return the contents of the " "source iterator. If you don't supply a value for *n*, the default is 2. " "Replicating iterators requires saving some of the contents of the source " "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. ::" #: howto/functional.rst:825 msgid "Calling functions on elements" msgstr "Appliquer des fonctions au contenu des itérateurs" #: howto/functional.rst:827 msgid "" "The :mod:`operator` module contains a set of functions corresponding to " "Python's operators. Some examples are :func:`operator.add(a, b) ` (adds two values), :func:`operator.ne(a, b) ` (same as " "``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``." #: howto/functional.rst:833 msgid "" ":func:`itertools.starmap(func, iter) ` assumes that the " "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 *n*-uplets et appelle *func* en utilisant " "tous les *n*-uplets comme arguments ::" #: howto/functional.rst:845 msgid "Selecting elements" msgstr "Sélectionner des éléments" #: howto/functional.rst:847 msgid "" "Another group of functions chooses a subset of an iterator's elements based " "on a predicate." msgstr "" "Une autre catégorie de fonctions est celle permettant de sélectionner un " "sous-ensemble des éléments de l'itérateur selon un prédicat donné." #: howto/functional.rst:850 msgid "" ":func:`itertools.filterfalse(predicate, iter) ` is " "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 ::" #: howto/functional.rst:857 msgid "" ":func:`itertools.takewhile(predicate, iter) ` returns " "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. ::" #: howto/functional.rst:870 msgid "" ":func:`itertools.dropwhile(predicate, iter) ` discards " "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. ::" #: howto/functional.rst:880 msgid "" ":func:`itertools.compress(data, selectors) ` takes two " "iterators and returns only those elements of *data* for which the " "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* est évalué à " "vrai. L'itération s'arrête lorsque l'un des deux itérateurs est épuisé ::" #: howto/functional.rst:889 msgid "Combinatoric functions" msgstr "Fonctions combinatoires" #: howto/functional.rst:891 msgid "" "The :func:`itertools.combinations(iterable, r) ` " "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*. ::" #: howto/functional.rst:906 msgid "" "The elements within each tuple remain in the same order as *iterable* " "returned them. For example, the number 1 is always before 2, 3, 4, or 5 in " "the examples above. A similar function, :func:`itertools." "permutations(iterable, r=None) `, removes this " "constraint on the order, returning all possible arrangements of length *r*::" msgstr "" "Les éléments de chaque *n*-uplet 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* ::" #: howto/functional.rst:925 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." #: howto/functional.rst:928 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 ::" #: howto/functional.rst:935 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." #: howto/functional.rst:938 msgid "" "The :func:`itertools.combinations_with_replacement(iterable, r) ` function relaxes a different constraint: " "elements can be repeated within a single tuple. Conceptually an element is " "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. ::" #: howto/functional.rst:953 msgid "Grouping elements" msgstr "Grouper les éléments" #: howto/functional.rst:955 msgid "" "The last function I'll discuss, :func:`itertools.groupby(iter, " "key_func=None) `, is the most complicated. " "``key_func(elem)`` is a function that can compute a key value for each " "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 est " "l'identité par défaut (c'est-à-dire que la clé d'un élément est l'élément " "lui-même)." #: howto/functional.rst:960 msgid "" ":func:`~itertools.groupby` collects all the consecutive elements from the " "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 paires contenant la " "clé et un itérateur produisant la liste des éléments pour cette clé." #: howto/functional.rst:988 msgid "" ":func:`~itertools.groupby` assumes that the underlying iterable's contents " "will already be sorted based on the key. Note that the returned iterators " "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 devez " "donc consommer l'intégralité des résultats du premier itérateur renvoyé " "(*iterator-1* dans l'exemple ci-dessus) avant de récupérer le deuxième " "itérateur (*iterator-2* dans l'exemple ci-dessus) et la clé à laquelle il " "est associé." #: howto/functional.rst:995 msgid "The functools module" msgstr "Le module *functools*" #: howto/functional.rst:997 #, fuzzy msgid "" "The :mod:`functools` module contains some higher-order functions. A **higher-" "order function** takes one or more functions as input 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`." #: howto/functional.rst:1002 msgid "" "For programs written in a functional style, you'll sometimes want to " "construct variants of existing functions that have some of the parameters " "filled in. Consider a Python function ``f(a, b, c)``; you may wish to create " "a new function ``g(b, c)`` that's equivalent to ``f(1, b, c)``; you're " "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 certains paramètres " "sont prédéfinis. Par exemple, considérons une fonction Python ``f(a, b, " "c)``. Si vous voulez 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()``." #: howto/functional.rst:1008 msgid "" "The constructor for :func:`~functools.partial` takes the arguments " "``(function, arg1, arg2, ..., kwarg1=value1, kwarg2=value2)``. The " "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." #: howto/functional.rst:1013 msgid "Here's a small but realistic example::" msgstr "Voici un exemple court mais réaliste ::" #: howto/functional.rst:1025 msgid "" ":func:`functools.reduce(func, iter, [initial_value]) ` " "cumulatively performs an operation on all the iterable's elements and, " "therefore, can't be applied to infinite iterables. *func* must be a function " "that takes two elements and returns a single value. :func:`functools." "reduce` takes the first two elements A and B returned by the iterator and " "calculates ``func(A, B)``. It then requests the third element, C, " "calculates ``func(func(A, B), C)``, combines this result with the fourth " "element returned, and continues until the iterable is exhausted. If the " "iterable returns no values at all, a :exc:`TypeError` exception is raised. " "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)``. ::" #: howto/functional.rst:1049 msgid "" "If you use :func:`operator.add` with :func:`functools.reduce`, you'll add up " "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 :" #: howto/functional.rst:1061 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` ::" #: howto/functional.rst:1073 msgid "" "A related function is :func:`itertools.accumulate(iterable, func=operator." "add) `. It performs the same calculation, but instead " "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 ::" #: howto/functional.rst:1086 msgid "The operator module" msgstr "Le module *operator*" #: howto/functional.rst:1088 msgid "" "The :mod:`operator` module was mentioned earlier. It contains a set of " "functions corresponding to Python's operators. These functions are often " "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." #: howto/functional.rst:1093 msgid "Some of the functions in this module are:" msgstr "Voici quelques fonctions de ce module :" # Énumération #: howto/functional.rst:1095 msgid "" "Math operations: ``add()``, ``sub()``, ``mul()``, ``floordiv()``, " "``abs()``, ..." msgstr "" "les opérations mathématiques : ``add()``, ``sub()``, ``mul()``, " "``floordiv()``, ``abs()``… ;" # Énumération #: howto/functional.rst:1096 msgid "Logical operations: ``not_()``, ``truth()``." msgstr "les opérations logiques : ``not_()``, ``truth()`` ;" # Énumération #: howto/functional.rst:1097 msgid "Bitwise operations: ``and_()``, ``or_()``, ``invert()``." msgstr "les opérations bit à bit : ``and_()``, ``or_()``, ``invert()`` ;" # Énumération #: howto/functional.rst:1098 msgid "" "Comparisons: ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, and ``ge()``." msgstr "" "les comparaisons : ``eq()``, ``ne()``, ``lt()``, ``le()``, ``gt()``, et " "``ge()`` ;" # Énumération #: howto/functional.rst:1099 msgid "Object identity: ``is_()``, ``is_not()``." msgstr "l'identification des objets : ``is_()``, ``is_not()``." #: howto/functional.rst:1101 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." #: howto/functional.rst:1105 msgid "Small functions and the lambda expression" msgstr "Expressions lambda et fonctions courtes" #: howto/functional.rst:1107 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." #: howto/functional.rst:1110 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 ::" #: howto/functional.rst:1116 msgid "" "If the function you need doesn't exist, you need to write it. One way to " "write small functions is to use the :keyword:`lambda` expression. " "``lambda`` takes a number of parameters and an expression combining these " "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 ::" #: howto/functional.rst:1125 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 ::" #: howto/functional.rst:1134 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 l'auteur évite " "l'utilisation de ``lambda``." #: howto/functional.rst:1137 msgid "" "One reason for my preference is that ``lambda`` is quite limited in the " "functions it can define. The result has to be computable as a single " "expression, which means you can't have multiway ``if... elif... else`` " "comparisons or ``try... except`` statements. If you try to do too much in a " "``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 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 ? ::" #: howto/functional.rst:1147 msgid "" "You can figure it out, but it takes time to disentangle the expression to " "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 ::" #: howto/functional.rst:1157 msgid "But it would be best of all if I had simply used a ``for`` loop::" msgstr "" "Toutefois l'idéal aurait été de simplement se contenter d'une boucle " "``for`` ::" #: howto/functional.rst:1163 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 ::" #: howto/functional.rst:1167 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`." #: howto/functional.rst:1169 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`` :" #: howto/functional.rst:1172 msgid "Write a lambda function." msgstr "Écrire une fonction lambda." #: howto/functional.rst:1173 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." #: howto/functional.rst:1174 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." #: howto/functional.rst:1176 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." #: howto/functional.rst:1177 msgid "Remove the comment." msgstr "Effacer le commentaire." #: howto/functional.rst:1179 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 préférer un style avec des lambdas." #: howto/functional.rst:1184 msgid "Revision History and Acknowledgements" msgstr "Historique des modifications et remerciements" #: howto/functional.rst:1186 msgid "" "The author would like to thank the following people for offering " "suggestions, corrections and assistance with various drafts of this article: " "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." #: howto/functional.rst:1191 msgid "Version 0.1: posted June 30 2006." msgstr "Version 0.1 : publiée le 30 juin 2006." #: howto/functional.rst:1193 msgid "Version 0.11: posted July 1 2006. Typo fixes." msgstr "" "Version 0.11 : publiée le 1\\ :sup:`er` juillet 2006. Correction " "orthographique." #: howto/functional.rst:1195 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." #: howto/functional.rst:1198 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*." #: howto/functional.rst:1200 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." #: howto/functional.rst:1205 msgid "References" msgstr "Références" #: howto/functional.rst:1208 msgid "General" msgstr "Général" #: howto/functional.rst:1210 msgid "" "**Structure and Interpretation of Computer Programs**, by Harold Abelson and " "Gerald Jay Sussman with Julie Sussman. Full text at https://mitpress.mit." "edu/sicp/. In this classic textbook of computer science, chapters 2 and 3 " "discuss the use of sequences and streams to organize the data flow inside a " "program. The book uses Scheme for its examples, but many of the design " "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." #: howto/functional.rst:1218 #, fuzzy msgid "" "https://www.defmacro.org/ramblings/fp.html: A general introduction to " "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." #: howto/functional.rst:1221 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." #: howto/functional.rst:1224 msgid "https://en.wikipedia.org/wiki/Coroutine: Entry for coroutines." msgstr "" "https://fr.wikipedia.org/wiki/Coroutine : l'entrée pour les coroutines." #: howto/functional.rst:1226 msgid "" "https://en.wikipedia.org/wiki/Currying: Entry for the concept of currying." msgstr "" "https://fr.wikipedia.org/wiki/Curryfication : l'entrée pour le concept de " "curryfication (création d'applications partielles)." #: howto/functional.rst:1229 msgid "Python-specific" msgstr "Spécifique à Python" #: howto/functional.rst:1231 #, fuzzy msgid "" "https://gnosis.cx/TPiP/: The first chapter of David Mertz's book :title-" "reference:`Text Processing in Python` discusses functional programming for " "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 »." #: howto/functional.rst:1236 msgid "" "Mertz also wrote a 3-part series of articles on functional programming for " "IBM's DeveloperWorks site; see `part 1 `__, `part 2 `__, and " "`part 3 `__," msgstr "" "Mertz a également écrit une série de 3 articles (en anglais) sur la " "programmation fonctionnelle pour le site DeveloperWorks d'IBM. Voir `partie " "1 `__, `partie 2 `__ et `partie 3 `__," #: howto/functional.rst:1244 msgid "Python documentation" msgstr "Documentation Python" #: howto/functional.rst:1246 msgid "Documentation for the :mod:`itertools` module." msgstr "Documentation du module :mod:`itertools`." #: howto/functional.rst:1248 msgid "Documentation for the :mod:`functools` module." msgstr "Documentation du module :mod:`functools`." #: howto/functional.rst:1250 msgid "Documentation for the :mod:`operator` module." msgstr "Documentation du module :mod:`operator`." #: howto/functional.rst:1252 msgid ":pep:`289`: \"Generator Expressions\"" msgstr ":pep:`289`: *\"Generator Expressions\"*" #: howto/functional.rst:1254 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."