AFPy/python-docs-fr
AFPy/python-docs-fr
Fork 80
Code Issues 5 Pull requests 9 Activity

Itertools (#886)

Browse source
This commit is contained in:
Antoine 2019-10-09 21:29:12 +02:00 • committed by Julien Palard
commit b48af1615d
1 changed files with 154 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

305
library/itertools.po
View file

@ -5,21 +5,20 @@ msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-10-09 17:54+0200\n"
"PO-Revision-Date: 2018-09-28 14:32+0200\n"
"Last-Translator: Raphaël Gomès <alphare33@gmail.com>\n"
"POT-Creation-Date: 2019-09-04 11:33+0200\n"
"PO-Revision-Date: 2019-09-28 18:16+0200\n"
"Last-Translator: Antoine Wecxsteen\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 1.8.7.1\n"
"X-Generator: Poedit 2.2.1\n"
#: ../Doc/library/itertools.rst:2
msgid ":mod:`itertools` --- Functions creating iterators for efficient looping"
msgstr ""
":mod:`itertools` --- Fonctions créant des itérateurs pour boucler "
"efficacement."
":mod:`itertools` — Fonctions créant des itérateurs pour boucler efficacement"
#: ../Doc/library/itertools.rst:16
msgid ""
@ -28,8 +27,8 @@ msgid ""
"suitable for Python."
msgstr ""
"Ce module implémente de nombreuses briques :term:`d'itérateurs <itérateur>` "
"inspirées par des constructions de APL, Haskell et SML. Toutes ont été "
"retravaillées dans un format adéquat pour Python."
"inspirées par des éléments de APL, Haskell et SML. Toutes ont été "
"retravaillées dans un format adapté à Python."
#: ../Doc/library/itertools.rst:20
msgid ""
@ -38,10 +37,10 @@ msgid ""
"algebra\" making it possible to construct specialized tools succinctly and "
"efficiently in pure Python."
msgstr ""
"Ce module standardise un noyau d'outils rapide, efficaces en mémoire qui "
"sont utiles d'eux-mêmes ou en les combinant. Ensemble, ils forment une "
"\"algèbre d'itérateurs\" rendant possible la construction succincte et "
"efficace d'outils spécialisés en Python seulement."
"Ce module standardise un ensemble de base d'outils rapides et efficaces en "
"mémoire qui peuvent être utilisés individuellement ou en les combinant. "
"Ensemble, ils forment une « algèbre d'itérateurs » rendant possible la "
"construction rapide et efficace d'outils spécialisés en Python."
#: ../Doc/library/itertools.rst:25
msgid ""
@ -50,7 +49,7 @@ msgid ""
"by combining :func:`map` and :func:`count` to form ``map(f, count())``."
msgstr ""
"Par exemple, SML fournit un outil de tabulation ``tabulate(f)`` qui produit "
"une séquence ``f(0), f(1), ...``. Le même résultat peut être achevé en "
"une séquence ``f(0), f(1), ...``. Le même résultat peut être obtenu en "
"Python en combinant :func:`map` et :func:`count` pour former ``map(f, "
"count())``."
@ -61,10 +60,10 @@ msgid ""
"multiplication operator can be mapped across two vectors to form an "
"efficient dot-product: ``sum(map(operator.mul, vector1, vector2))``."
msgstr ""
"Ces outils et leurs équivalents intégrés fonctionnent aussi bien avec les "
"fonction à grande vitesse dans le module :mod:`operator`. Par exemple, "
"l'opérateur de multiplication peut être appliqué à deux vecteurs pour créer "
"un produit scalaire efficace ``sum(map(operator.mul, vecteur1, vecteur2))``."
"Ces outils et leurs équivalents natifs fonctionnent également bien avec les "
"fonctions optimisées du module :mod:`operator`. Par exemple, l'opérateur de "
"multiplication peut être appliqué à deux vecteurs pour créer un produit "
"scalaire efficace : ``sum(map(operator.mul, vecteur1, vecteur2))``."
#: ../Doc/library/itertools.rst:35
msgid "**Infinite iterators:**"
@ -224,7 +223,7 @@ msgstr ":func:`filterfalse`"
#: ../Doc/library/itertools.rst:55
msgid "elements of seq where pred(elem) is false"
msgstr "éléments de *seq* quand *pred(elem)* est faux"
msgstr "éléments de *seq* pour lesquels *pred(elem)* est faux"
#: ../Doc/library/itertools.rst:55
msgid "``filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8``"
@ -337,8 +336,8 @@ msgstr "p[, r]"
#: ../Doc/library/itertools.rst:70
msgid "r-length tuples, all possible orderings, no repeated elements"
msgstr ""
"*tuples* de longueur *r*, tous les ré-arrangements possibles, sans "
"répétition d'éléments"
"n-uplets de longueur r, tous les ré-arrangements possibles, sans répétition "
"d'éléments"
#: ../Doc/library/itertools.rst:71
msgid ":func:`combinations`"
@ -350,7 +349,7 @@ msgstr "p, r"
#: ../Doc/library/itertools.rst:71
msgid "r-length tuples, in sorted order, no repeated elements"
msgstr "tuples de longueur r, triés, sans répétition d'éléments"
msgstr "n-uplets de longueur r, ordonnés, sans répétition d'éléments"
#: ../Doc/library/itertools.rst:72
msgid ":func:`combinations_with_replacement`"
@ -358,12 +357,11 @@ msgstr ":func:`combinations_with_replacement`"
#: ../Doc/library/itertools.rst:72
msgid "r-length tuples, in sorted order, with repeated elements"
msgstr "tuples de longueur r, triés, avec répétition d'éléments"
msgstr "n-uplets de longueur r, ordonnés, avec répétition d'éléments"
#: ../Doc/library/itertools.rst:76
#, fuzzy
msgid "Examples"
msgstr "Exemple"
msgstr "Exemples"
#: ../Doc/library/itertools.rst:78
msgid "``product('ABCD', repeat=2)``"
@ -390,7 +388,6 @@ msgid "``AB AC AD BC BD CD``"
msgstr "``AB AC AD BC BD CD``"
#: ../Doc/library/itertools.rst:81
#, fuzzy
msgid "``combinations_with_replacement('ABCD', 2)``"
msgstr "``combinations_with_replacement('ABCD', 2)``"
@ -408,19 +405,20 @@ msgid ""
"provide streams of infinite length, so they should only be accessed by "
"functions or loops that truncate the stream."
msgstr ""
"Toutes les fonctions de module qui suivent construisent et renvoient des "
"itérateurs. Certaines fournissent des flux de longueur infinie, elles "
"devraient seulement être accédées par des fonctions ou boucles qui tronquent "
"le flux."
"Toutes les fonctions du module qui suivent construisent et renvoient des "
"itérateurs. Certaines produisent des flux de longueur infinie ; celles-ci ne "
"doivent donc être contrôlées que par des fonctions ou boucles qui "
"interrompent le flux."
#: ../Doc/library/itertools.rst:96
msgid ""
"Make an iterator that returns accumulated sums, or accumulated results of "
"other binary functions (specified via the optional *func* argument)."
msgstr ""
"Crée un itérateur qui renvoie les sommes cumulées, ou les résultats cumulés "
"d'autres fonctions binaires (spécifiées par l'argument optionnel *func*)."
#: ../Doc/library/itertools.rst:100
#, fuzzy
msgid ""
"If *func* is supplied, it should be a function of two arguments. Elements of "
"the input *iterable* may be any type that can be accepted as arguments to "
@ -428,15 +426,12 @@ msgid ""
"be any addable type including :class:`~decimal.Decimal` or :class:"
"`~fractions.Fraction`.)"
msgstr ""
"Créer un itérateur qui renvoie les sommes accumulées, ou les résultats "
"accumulés d'autres fonctions binaires (spécifiées par l'argument optionnel "
"*func*). Si *func* est renseigné, il doit être une fonction à deux "
"arguments. Les éléments de l'itérable d'entrée peuvent être de n'importe "
"quel type qui peuvent être acceptés comme arguments de *func*. (Par exemple, "
"avec l'opération par défaut d'addition, les éléments peuvent être de "
"n'importe quel type additionnable incluant :class:`~decimal.Decimal` ou :"
"class:`~fractions.Fraction`.) Si l'itérable d'entrée est vide, l'itérable de "
"sortie sera aussi vide."
"Si *func* est renseigné, il doit être une fonction à deux arguments. Les "
"éléments de l'entrée *iterable* peuvent être de n'importe quel type "
"acceptable comme arguments de *func*. Par exemple, avec l'opération par "
"défaut d'addition, les éléments peuvent être de n'importe quel type "
"additionnable, :class:`~decimal.Decimal` ou :class:`~fractions.Fraction` "
"inclus."
#: ../Doc/library/itertools.rst:107
msgid ""
@ -445,12 +440,17 @@ msgid ""
"with the *initial* value so that the output has one more element than the "
"input iterable."
msgstr ""
"De manière générale, le nombre d'éléments produits par la sortie correspond "
"au nombre d'éléments de *'iterable* en entrée. Cependant, si le paramètre "
"nommé *initial* est fourni, l'accumulation conserve comme premier élément la "
"valeur de *initial* et donc la sortie compte un élément de plus que ce qui "
"est produit par l'entrée *iterable*."
#: ../Doc/library/itertools.rst:112 ../Doc/library/itertools.rst:210
#: ../Doc/library/itertools.rst:259 ../Doc/library/itertools.rst:495
#: ../Doc/library/itertools.rst:574 ../Doc/library/itertools.rst:627
msgid "Roughly equivalent to::"
msgstr "Sensiblement équivalent à : ::"
msgstr "À peu près équivalent à :"
#: ../Doc/library/itertools.rst:131
msgid ""
@ -462,14 +462,15 @@ msgid ""
"modeled by supplying the initial value in the iterable and using only the "
"accumulated total in *func* argument::"
msgstr ""
"Il y a de nombreuses utilisations pour l'argument *func*. Il peut être :func:"
"`min` pour un minimum glissant, :func:`max` pour un maximum glissant, ou :"
"func:`operator.mul` pour un produit glissant. Des tableaux de remboursement "
"peuvent être construites en accumulant l'intérêt et en déposant des "
"paiements. Des `suites de récurrences <https://fr.wikipedia.org/wiki/Suite_d"
"%C3%A9finie_par_r%C3%A9currence>`_ de premier ordre peuvent être modélisées "
"en renseignant la valeur initiale dans l'itérable et en utilisant seulement "
"le total accumulé dans l'argument *func* : ::"
"Il y a de nombreuses utilisations à l'argument *func*. Celui-ci peut être :"
"func:`min` pour calculer un minimum glissant, :func:`max` pour un maximum "
"glissant ou :func:`operator.mul` pour un produit glissant. Des tableaux de "
"remboursements peuvent être construits en ajoutant les intérêts et en "
"soustrayant les paiements. Des `suites par récurrence <https://fr.wikipedia."
"org/wiki/Suite_d%C3%A9finie_par_r%C3%A9currence>`_ de premier ordre peuvent "
"être modélisées en en passant la valeur initiale dans *iterable* et en "
"n'utilisant que le premier argument de *func*, qui contient le résultat des "
"évaluations précédentes."
#: ../Doc/library/itertools.rst:161
msgid ""
@ -481,12 +482,11 @@ msgstr ""
#: ../Doc/library/itertools.rst:166
msgid "Added the optional *func* parameter."
msgstr "Le paramètre optionnel *func* a été ajouté."
msgstr "Ajout du paramètre optionnel *func*."
#: ../Doc/library/itertools.rst:169
#, fuzzy
msgid "Added the optional *initial* parameter."
msgstr "Le paramètre optionnel *func* a été ajouté."
msgstr "Ajout du paramètre optionnel *initial*."
#: ../Doc/library/itertools.rst:174
msgid ""
@ -495,10 +495,10 @@ msgid ""
"are exhausted. Used for treating consecutive sequences as a single "
"sequence. Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui renvoie les éléments du premier itérable jusqu'à son "
"Crée un itérateur qui renvoie les éléments du premier itérable jusqu'à son "
"épuisement, puis continue avec l'itérable suivant jusqu'à ce que tous les "
"itérables soient épuisés. Utilisée pour traiter des séquences consécutives "
"comme une seule séquence Sensiblement équivalente à : ::"
"comme une seule séquence. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:188
msgid ""
@ -506,12 +506,12 @@ msgid ""
"iterable argument that is evaluated lazily. Roughly equivalent to::"
msgstr ""
"Constructeur alternatif pour :func:`chain`. Récupère des entrées chaînées "
"d'un unique argument itérable qui est évalué de manière paresseuse. "
"Sensiblement équivalente à : ::"
"depuis un unique itérable passé en argument, qui est évalué de manière "
"paresseuse. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:200
msgid "Return *r* length subsequences of elements from the input *iterable*."
msgstr "Renvoyer les sous-séquences de longueur *r* de l'itérable *iterable*."
msgstr "Renvoie les combinaisons de longueur *r* de *iterable*."
#: ../Doc/library/itertools.rst:202 ../Doc/library/itertools.rst:251
msgid ""
@ -519,9 +519,9 @@ msgid ""
"*iterable* is sorted, the combination tuples will be produced in sorted "
"order."
msgstr ""
"Les combinaisons sont émises dans l'ordre lexicographique. Ainsi, si "
"l'itérable *iterable* est trié, les *tuples* de combinaison seront produits "
"dans l'ordre."
"Les combinaisons sont produites dans l'ordre lexicographique. Ainsi, si "
"l'itérable *iterable* est ordonné, les n-uplets de combinaison produits le "
"sont aussi."
#: ../Doc/library/itertools.rst:206
msgid ""
@ -539,9 +539,9 @@ msgid ""
"func:`permutations` after filtering entries where the elements are not in "
"sorted order (according to their position in the input pool)::"
msgstr ""
"Le code de :func:`combinations` peut aussi être exprimé comme une sous-"
"séquence de :func:`permutations` après avoir filtré les entrées dont les "
"éléments ne sont pas triés (selon leur position dans le *pool* d'entrée) : ::"
"Un appel à :func:`combinations` peut aussi être vu comme à un appel à :func:"
"`permutations` en excluant les sorties dans lesquelles les éléments ne sont "
"pas ordonnés (avec la même relation d'ordre que pour l'entrée) :"
#: ../Doc/library/itertools.rst:243
msgid ""
@ -576,10 +576,9 @@ msgid ""
"a subsequence of :func:`product` after filtering entries where the elements "
"are not in sorted order (according to their position in the input pool)::"
msgstr ""
"Le code pour :func:`combinations_with_replacement` peut aussi être exprimé "
"comme une sous-séquence de :func:`product` après avoir filtré les entrées où "
"les éléments ne sont pas dans triés (selon leur position dans le *pool* "
"d'entrée) : ::"
"Un appel à :func:`combinations_with_replacement` peut aussi être vu comme un "
"appel à :func:`product` en excluant les sorties dans lesquelles les éléments "
"ne sont pas dans ordonnés (avec la même relation d'ordre que pour l'entrée) :"
#: ../Doc/library/itertools.rst:289
msgid ""
@ -594,10 +593,10 @@ msgid ""
"Stops when either the *data* or *selectors* iterables has been exhausted. "
"Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui filtre les éléments de *data*, renvoyant seulement "
"ceux qui ont un élément correspondant dans *selectors* qui évalue à "
"``True``. S'arrête quand l'itérable *data* ou *selectors* a été épuisé. "
"Sensiblement équivalent à : ::"
"Crée un itérateur qui filtre les éléments de *data*, en ne renvoyant que "
"ceux dont l'élément correspondant dans *selectors* s'évalue à ``True``. "
"S'arrête quand l'itérable *data* ou *selectors* a été épuisé. À peu près "
"équivalent à :"
#: ../Doc/library/itertools.rst:310
msgid ""
@ -606,10 +605,10 @@ msgid ""
"data points. Also, used with :func:`zip` to add sequence numbers. Roughly "
"equivalent to::"
msgstr ""
"Créer un itérateur qui renvoie les valeurs espacées également commençant par "
"le nombre *start*. Souvent utilisée comme un argument de :func:`map` pour "
"générer des points de données consécutifs. Aussi utilisé avec :func:`zip` "
"pour ajouter des nombres de séquence. Sensiblement équivalent à : ::"
"Crée un itérateur qui renvoie des valeurs espacées régulièrement, en "
"commençant par le nombre *start*. Souvent utilisé comme un argument de :func:"
"`map` pour générer des points de données consécutifs. Aussi utilisé avec :"
"func:`zip` pour ajouter des nombres de séquence. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:322
msgid ""
@ -617,9 +616,9 @@ msgid ""
"achieved by substituting multiplicative code such as: ``(start + step * i "
"for i in count())``."
msgstr ""
"Quand on compte avec des nombres à virgule flottante, il est parfois "
"possible d'obtenir une meilleure précision en substituant du code "
"multiplicateur comme : ``(start + step * i for i in count())``."
"Pour compter avec des nombres à virgule flottante, il est parfois préférable "
"d'utiliser le code : ``(start + step * i for i in count())`` pour obtenir "
"une meilleure précision."
#: ../Doc/library/itertools.rst:326
msgid "Added *step* argument and allowed non-integer arguments."
@ -633,18 +632,17 @@ msgid ""
"each. When the iterable is exhausted, return elements from the saved copy. "
"Repeats indefinitely. Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui renvoie les éléments de l'itérable et qui sauvegarde "
"une copie de chaque. Quand l'itérable est épuisé, renvoyer les éléments "
"depuis la copie sauvegardée. Répète à l'infini. Sensiblement équivalent "
"à : ::"
"Crée un itérateur qui renvoie les éléments de l'itérable en en sauvegardant "
"une copie. Quand l'itérable est épuisé, renvoie les éléments depuis la "
"sauvegarde. Répète à l'infini. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:345
msgid ""
"Note, this member of the toolkit may require significant auxiliary storage "
"(depending on the length of the iterable)."
msgstr ""
"Note, cette fonction pourrait avoir besoin d'un stockage auxiliaire "
"important (en fonction de la longueur de l'itérable)."
"Note, cette fonction peut avoir besoin d'un stockage auxiliaire important "
"(en fonction de la longueur de l'itérable)."
#: ../Doc/library/itertools.rst:351
msgid ""
@ -653,10 +651,10 @@ msgid ""
"does not produce *any* output until the predicate first becomes false, so it "
"may have a lengthy start-up time. Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui saute les éléments de l'itérable tant que le prédicat "
"est vrai ; ensuite, renvoyer chaque élément. Note, l'itérateur ne produit "
"Crée un itérateur qui saute les éléments de l'itérable tant que le prédicat "
"est vrai ; renvoie ensuite chaque élément. Notez que l'itérateur ne produit "
"*aucune* sortie avant que le prédicat ne devienne faux, il peut donc avoir "
"un temps de démarrage long. Sensiblement équivalent à : ::"
"un temps de démarrage long. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:368
msgid ""
@ -664,9 +662,9 @@ msgid ""
"for which the predicate is ``False``. If *predicate* is ``None``, return the "
"items that are false. Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui filtre les éléments de *iterable*, ne renvoyant "
"seulement ceux pour lesquels le prédicat est ``Faux``. Si *predicate* vaut "
"``None``, renvoyer les éléments qui sont faux. Sensiblement équivalent à : ::"
"Crée un itérateur qui filtre les éléments de *iterable*, ne renvoyant "
"seulement ceux pour lesquels le prédicat est ``False``. Si *predicate* vaut "
"``None``, renvoie les éléments qui sont faux. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:383
msgid ""
@ -676,12 +674,12 @@ msgid ""
"returns the element unchanged. Generally, the iterable needs to already be "
"sorted on the same key function."
msgstr ""
"Créer un itérateur qui renvoie les clés et les groupes de l'itérable "
"Crée un itérateur qui renvoie les clés et les groupes de l'itérable "
"*iterable*. La clé *key* est une fonction qui génère une clé pour chaque "
"élément. Si *key* n'est pas spécifié ou est ``None``, elle vaut par défaut "
"élément. Si *key* n'est pas spécifiée ou est ``None``, elle vaut par défaut "
"une fonction d'identité qui renvoie l'élément sans le modifier. "
"Généralement, l'itérable a besoin d'être déjà trié selon cette même fonction "
"de clé."
"Généralement, l'itérable a besoin d'avoir ses éléments déjà classés selon "
"cette même fonction de clé."
#: ../Doc/library/itertools.rst:389
msgid ""
@ -708,12 +706,12 @@ msgstr ""
"Le groupe renvoyé est lui-même un itérateur qui partage l'itérable sous-"
"jacent avec :func:`groupby`. Puisque que la source est partagée, quand "
"l'objet :func:`groupby` est avancé, le groupe précédent n'est plus visible. "
"Ainsi, si cette donnée doit être utilisée plus tard, elle devrait être "
"stockée comme une liste : ::"
"Ainsi, si cette donnée doit être utilisée plus tard, elle doit être stockée "
"comme une liste :"
#: ../Doc/library/itertools.rst:407
msgid ":func:`groupby` is roughly equivalent to::"
msgstr ":func:`groupby` est sensiblement équivalent à : ::"
msgstr ":func:`groupby` est à peu près équivalente à :"
#: ../Doc/library/itertools.rst:440
msgid ""
@ -728,18 +726,18 @@ msgid ""
"the internal structure has been flattened (for example, a multi-line report "
"may list a name field on every third line). Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui renvoie les élément sélectionnés de l'itérable. Si "
"*start* est non-nul, alors les éléments de l'itérable sont sautés jusqu'à ce "
"que *start* soit atteint. Ensuite, les éléments sont renvoyés "
"Crée un itérateur qui renvoie les élément sélectionnés de l'itérable. Si "
"*start* est différent de zéro, alors les éléments de l'itérable sont ignorés "
"jusqu'à ce que *start* soit atteint. Ensuite, les éléments sont renvoyés "
"consécutivement sauf si *step* est plus grand que 1, auquel cas certains "
"éléments seront sautés. Si *stop* est ``None``, alors l'itération continue "
"éléments seront ignorés. Si *stop* est ``None``, alors l'itération continue "
"jusqu'à ce que l'itérateur soit épuisé s'il ne l'est pas déjà ; sinon, il "
"s'arrête à la position spécifiée. À la différence du *slicing* standard, :"
"func:`slice` ne supporte pas les valeurs négatives pour *start*, *stop* ou "
"*step*. Peut être utilisée pour extraire les champs apparentés depuis des "
"s'arrête à la position spécifiée. À la différence des tranches standards, :"
"func:`slice` ne gère pas les valeurs négatives pour *start*, *stop* ou "
"*step*. Peut être utilisée pour extraire les champs consécutifs depuis des "
"données dont la structure interne a été aplatie (par exemple, un rapport "
"multi-ligne pourrait lister un nom de champ toutes les trois lignes). "
"Sensiblement similaire à : ::"
"multi-lignes pourrait lister un nom de champ toutes les trois lignes). À peu "
"près similaire à :"
#: ../Doc/library/itertools.rst:475
msgid ""
@ -753,7 +751,7 @@ msgstr ""
msgid ""
"Return successive *r* length permutations of elements in the *iterable*."
msgstr ""
"Renvoyer les permutations successives de longueur *r* des éléments de "
"Renvoie les arrangements successifs de longueur *r* des éléments de "
"*iterable*."
#: ../Doc/library/itertools.rst:483
@ -772,8 +770,8 @@ msgid ""
"order."
msgstr ""
"Les permutations sont émises dans l'ordre lexicographique. Ainsi, si "
"l'itérable d'entrée *iterable* est trié, les *tuples* de permutation seront "
"produits dans l'ordre."
"l'itérable d'entrée *iterable* est classé, les n-uplets de permutation sont "
"produits dans ce même ordre."
#: ../Doc/library/itertools.rst:491
msgid ""
@ -791,9 +789,9 @@ msgid ""
"func:`product`, filtered to exclude entries with repeated elements (those "
"from the same position in the input pool)::"
msgstr ""
"Le code pour :func:`permutations` peut aussi être exprimé comme une sous-"
"séquence de :func:`product`, filtré pour exclure les entrées avec des "
"éléments répétés (celles de la même position dans la *pool* d'entrée) : ::"
"Un appel à :func:`permutations` peut aussi être vu un appel à :func:"
"`product` en excluant les sorties avec des doublons (avec la même relation "
"d'ordre que pour l'entrée) : "
#: ../Doc/library/itertools.rst:534
msgid ""
@ -813,9 +811,9 @@ msgid ""
"example, ``product(A, B)`` returns the same as ``((x,y) for x in A for y in "
"B)``."
msgstr ""
"Sensiblement équivalent à des boucles *for* imbriquées dans une expression "
"de générateur. Par exemple ``product(A, B)`` renvoie la même chose que "
"``((x, y) for x in A for y in B)``."
"À peu près équivalent à des boucles *for* imbriquées dans une expression de "
"générateur. Par exemple ``product(A, B)`` renvoie la même chose que ``((x, "
"y) for x in A for y in B)``."
#: ../Doc/library/itertools.rst:544
msgid ""
@ -825,9 +823,9 @@ msgid ""
"sorted order."
msgstr ""
"Les boucles imbriquées tournent comme un compteur kilométrique avec "
"l'élément le plus à droite avançant à chaque itération. ce motif créé un tri "
"lexicographique afin que si les itérables de l'entrée sont triés, les "
"*tuples* de produit sont émis dans l'ordre."
"l'élément le plus à droite avançant à chaque itération. Ce motif défini un "
"ordre lexicographique afin que, si les éléments des itérables en l'entrée "
"sont ordonnés, les n-uplets produits le sont aussi."
#: ../Doc/library/itertools.rst:549
msgid ""
@ -835,17 +833,18 @@ msgid ""
"repetitions with the optional *repeat* keyword argument. For example, "
"``product(A, repeat=4)`` means the same as ``product(A, A, A, A)``."
msgstr ""
"Pour générer le produit d'un itérable avec lui-même, spécifier le nombre de "
"Pour générer le produit d'un itérable avec lui-même, spécifiez le nombre de "
"répétitions avec le paramètre nommé optionnel *repeat*. Par exemple, "
"``product(A, repeat=4)`` veut dire la même chose que ``product(A, A, A, A)``."
"``product(A, repeat=4)`` est équivalent à ``product(A, A, A, A)``."
#: ../Doc/library/itertools.rst:553
msgid ""
"This function is roughly equivalent to the following code, except that the "
"actual implementation does not build up intermediate results in memory::"
msgstr ""
"Cette fonction est sensiblement équivalente au code suivant, saut que la "
"vraie implémentation ne créé pas les résultats intermédiaires en mémoire : ::"
"Cette fonction est à peu près équivalente au code suivant, à la différence "
"près que la vraie implémentation ne crée pas de résultats intermédiaires en "
"mémoire :"
#: ../Doc/library/itertools.rst:569
msgid ""
@ -854,18 +853,18 @@ msgid ""
"func:`map` for invariant parameters to the called function. Also used with :"
"func:`zip` to create an invariant part of a tuple record."
msgstr ""
"Créer un itérateur qui renvoie *object* à l'infini. S'exécute indéfiniment "
"Crée un itérateur qui renvoie *object* à l'infini. S'exécute indéfiniment "
"sauf si l'argument *times* est spécifié. Utilisée comme argument de :func:"
"`map` pour les paramètres invariants de la fonction appelée. Aussi utilisée "
"avec :func:`zip` pour créer une partie invariante d'un *tuple*."
"avec :func:`zip` pour créer une partie invariante d'un n-uplet."
#: ../Doc/library/itertools.rst:585
msgid ""
"A common use for *repeat* is to supply a stream of constant values to *map* "
"or *zip*::"
msgstr ""
"Une utilisation commune de *repeat* est de fournir un flux constant de "
"valeurs à *map* ou *zip* : ::"
"Une utilisation courante de *repeat* est de fournir un flux constant de "
"valeurs à *map* ou *zip* :"
#: ../Doc/library/itertools.rst:593
msgid ""
@ -876,24 +875,24 @@ msgid ""
"the distinction between ``function(a,b)`` and ``function(*c)``. Roughly "
"equivalent to::"
msgstr ""
"Créer un itérateur qui exécute la fonction avec les arguments obtenus de "
"Crée un itérateur qui exécute la fonction avec les arguments obtenus depuis "
"l'itérable. Utilisée à la place de :func:`map` quand les arguments sont déjà "
"groupés en *tuples* depuis un seul itérable (la donnée a déjà été \"pré-"
"zippée\"). La différence entre :func:`map` et :func:`starmap` est similaire "
"à la différence entre ``fonction(a,b)`` et ``fonction(*c)``. Sensiblement "
"équivalent à : ::"
"groupés en n-uplets depuis un seul itérable — la donnée a déjà été « pré-"
"zippée ». La différence entre :func:`map` et :func:`starmap` est similaire à "
"la différence entre ``fonction(a,b)`` et ``fonction(*c)``. À peu près "
"équivalent à :"
#: ../Doc/library/itertools.rst:607
msgid ""
"Make an iterator that returns elements from the iterable as long as the "
"predicate is true. Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui renvoie les éléments d'un itérable tant que le "
"prédicat est vrai. Sensiblement équivalent à : ::"
"Crée un itérateur qui renvoie les éléments d'un itérable tant que le "
"prédicat est vrai. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:621
msgid "Return *n* independent iterators from a single iterable."
msgstr "Renvoyer *n* itérateurs indépendant depuis un unique itérable."
msgstr "Renvoie *n* itérateurs indépendants depuis un unique itérable."
#: ../Doc/library/itertools.rst:623
msgid ""
@ -901,9 +900,9 @@ msgid ""
"implementation is more complex and uses only a single underlying :abbr:`FIFO "
"(first-in, first-out)` queue)."
msgstr ""
"Le code Python qui suit aide à expliquer ce que fait *tee* (bien que la "
"vraie implémentation est plus complexe et n'utilise qu'une file :abbr:`FIFO "
"(first-in, first-out)`)."
"Le code Python qui suit aide à expliquer ce que fait *tee*, bien que la "
"vraie implémentation soit plus complexe et n'utilise qu'une file :abbr:`FIFO "
"(premier entré, premier sorti ou *first-in, first-out* en anglais)`."
#: ../Doc/library/itertools.rst:644
msgid ""
@ -912,8 +911,8 @@ msgid ""
"tee objects being informed."
msgstr ""
"Une fois que :func:`tee` a créé un branchement, l'itérable *iterable* ne "
"devrait être utilisé nulle part ailleurs ; sinon, *iterable* pourrait être "
"avancé sans que les objets tee soient informés."
"doit être utilisé nulle part ailleurs ; sinon, *iterable* pourrait être "
"avancé sans que les objets tee ne soient informés."
#: ../Doc/library/itertools.rst:648
msgid ""
@ -929,11 +928,11 @@ msgid ""
"most or all of the data before another iterator starts, it is faster to use :"
"func:`list` instead of :func:`tee`."
msgstr ""
"Cet outil pourrait avoir besoin d'un stockage auxiliaire important (en "
"fonction de la taille des données temporaires nécessaires). En général, si "
"un itérateur utilise la majorité ou toute la donnée avant qu'un autre "
"itérateur ne commence, il est plus rapide d'utiliser :func:`list` à la place "
"de :func:`tee`."
"Cet outil peut avoir besoin d'un stockage auxiliaire important (en fonction "
"de la taille des données temporaires nécessaires). En général, si un "
"itérateur utilise la majorité ou toute la donnée avant qu'un autre itérateur "
"ne commence, il est plus rapide d'utiliser :func:`list` à la place de :func:"
"`tee`."
#: ../Doc/library/itertools.rst:660
msgid ""
@ -942,10 +941,10 @@ msgid ""
"*fillvalue*. Iteration continues until the longest iterable is exhausted. "
"Roughly equivalent to::"
msgstr ""
"Créer un itérateur qui agrège les éléments de chacun des itérables. Si les "
"Crée un itérateur qui agrège les éléments de chacun des itérables. Si les "
"itérables sont de longueurs différentes, les valeurs manquantes sont "
"remplacées par *fillvalue*. L'itération continue jusqu'à ce que l'itérable "
"le plus long soit épuisé. Sensiblement équivalent à : ::"
"le plus long soit épuisé. À peu près équivalent à :"
#: ../Doc/library/itertools.rst:684
msgid ""
@ -955,7 +954,7 @@ msgid ""
"specified, *fillvalue* defaults to ``None``."
msgstr ""
"Si un des itérables est potentiellement infini, alors la fonction :func:"
"`zip_longest` devrait être entourée avec quelque chose qui limite le nombre "
"`zip_longest` doit être encapsulée dans un code qui limite le nombre "
"d'appels (par exemple, :func:`islice` ou :func:`takewhile`). Si *fillvalue* "
"n'est pas spécifié, il vaut ``None`` par défaut."
@ -968,8 +967,8 @@ msgid ""
"This section shows recipes for creating an extended toolset using the "
"existing itertools as building blocks."
msgstr ""
"Cette section montre des recettes pour créer une boîte à outil étendue en se "
"servant des *itertools* existants comme de briques."
"Cette section présente des recettes pour créer une vaste boîte à outils en "
"se servant des *itertools* existants comme des briques."
#: ../Doc/library/itertools.rst:698
msgid ""
@ -977,6 +976,9 @@ msgid ""
"from the `more-itertools project <https://pypi.org/project/more-itertools/"
">`_ found on the Python Package Index::"
msgstr ""
"Toutes ces recettes — et encore beaucoup d'autres — sont regroupées dans le "
"`projet more-itertools <https://pypi.org/project/more-itertools/>`_, "
"disponible dans le Python Package Index ::"
#: ../Doc/library/itertools.rst:704
msgid ""
@ -992,9 +994,10 @@ msgstr ""
"jacents. La performance mémoire supérieure est gardée en traitant les "
"éléments un à la fois plutôt que de charger tout l'itérable en mémoire en "
"même temps. Le volume de code reste bas grâce à un chaînage de style "
"fonctionnel qui aide à éliminer des variables temporaires. La grande vitesse "
"est gardée en préférant les briques \"vectorisées\" plutôt que les boucles "
"*for* et les :term:`générateur`\\s qui engendrent du sur-coût de traitement."
"fonctionnel qui aide à éliminer les variables temporaires. La grande vitesse "
"est gardée en préférant les briques « vectorisées » plutôt que les boucles "
"*for* et les :term:`générateurs <generator>` qui engendrent un surcoût de "
"traitement."
#~ msgid ""
#~ "Note, many of the above recipes can be optimized by replacing global "