# 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: 2024-11-01 00:16+0100\n"

"PO-Revision-Date: 2022-05-12 09:39+0200\n"

"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\n"

"Language-Team: FRENCH <traductions@lists.afpy.org>\n"

"Language: fr\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"X-Generator: Poedit 3.0.1\n"

#: howto/functional.rst:5

msgid "Functional Programming HOWTO"

msgstr "Guide pratique : programmation fonctionnelle"

#: howto/functional.rst:0

msgid "Author"

msgstr "Auteur"

#: howto/functional.rst:7

msgid "A. M. Kuchling"

msgstr "A. M. Kuchling"

#: howto/functional.rst:0

msgid "Release"

msgstr "Version"

#: howto/functional.rst:8

msgid "0.32"

msgstr "0.32"

#: howto/functional.rst:10

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:18

msgid "Introduction"

msgstr "Introduction"

#: howto/functional.rst:20

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:24

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:26

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:30

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:37

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:43

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:49

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:60

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:68

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:75

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:81

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:90

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:94

msgid "Formal provability."

msgstr "preuves formelles ;"

# Énumération

#: howto/functional.rst:95

msgid "Modularity."

msgstr "modularité ;"

# Énumération

#: howto/functional.rst:96

msgid "Composability."

msgstr "composabilité ;"

# Énumération

#: howto/functional.rst:97

msgid "Ease of debugging and testing."

msgstr "facilité de débogage et de test."

#: howto/functional.rst:101

msgid "Formal provability"

msgstr "Preuves formelles"

#: howto/functional.rst:103

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:106

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:113

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:121

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:126

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:137

msgid "Modularity"

msgstr "Modularité"

#: howto/functional.rst:139

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:147

msgid "Ease of debugging and testing"

msgstr "Facilité de débogage et de test"

#: howto/functional.rst:149

msgid "Testing and debugging a functional-style program is easier."

msgstr "Tester et déboguer un programme fonctionnel est plus facile."

#: howto/functional.rst:151

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:156

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:163

msgid "Composability"

msgstr "Composabilité"

#: howto/functional.rst:165

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:172

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:180

msgid "Iterators"

msgstr "Itérateurs"

#: howto/functional.rst:182

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:185

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:193

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:200

msgid "You can experiment with the iteration interface manually:"

msgstr "Vous pouvez expérimenter avec l'interface d'itération manuellement :"

#: howto/functional.rst:218

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:230

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:239

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:248

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:256

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:266

msgid "Data Types That Support Iterators"

msgstr "Types de données itérables"

#: howto/functional.rst:268

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:272

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:292

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:296

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:302

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:309

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:317

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:333

msgid "Generator expressions and list comprehensions"

msgstr "Expressions génératrices et compréhension de listes"

#: howto/functional.rst:335

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:341

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:354

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:359

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:366

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:380

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:383

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:387

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:393

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:399

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:416

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:428

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:439

msgid "Generators"

msgstr "Générateurs"

#: howto/functional.rst:441

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:445

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:454

msgid "Here's the simplest example of a generator function:"

msgstr "Voici un exemple simple de fonction génératrice :"

#: howto/functional.rst:460

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:464

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:473

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:490

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:493

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:498

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:506

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:522

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:530

msgid "Passing values into a generator"

msgstr "Transmettre des valeurs au générateur"

#: howto/functional.rst:532

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:539

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:545

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:550

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:556

msgid ""

"Values are sent into a generator by calling its :meth:`send(value) "

"<generator.send>` 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) <generator.send>`. 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:561

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:576

msgid "And here's an example of changing the counter:"

msgstr "Et voici comment il est possible de modifier le compteur :"

#: howto/functional.rst:593

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 "