forked from AFPy/python-docs-fr
Add translation for the itertools module
This commit is contained in:
parent
f2d8dcf5e4
commit
53cb23a627
|
@ -3,23 +3,25 @@
|
|||
# This file is distributed under the same license as the Python package.
|
||||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||||
#
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: Python 3.6\n"
|
||||
"Report-Msgid-Bugs-To: \n"
|
||||
"POT-Creation-Date: 2017-04-02 22:11+0200\n"
|
||||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||||
"PO-Revision-Date: 2017-09-21 15:32+0200\n"
|
||||
"Language: fr\n"
|
||||
"MIME-Version: 1.0\n"
|
||||
"Content-Type: text/plain; charset=UTF-8\n"
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Last-Translator: Raphaël Gomès <alphare33@gmail.com>\n"
|
||||
"Language-Team: \n"
|
||||
"X-Generator: Poedit 1.8.7.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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:16
|
||||
msgid ""
|
||||
|
@ -27,6 +29,9 @@ msgid ""
|
|||
"by constructs from APL, Haskell, and SML. Each has been recast in a form "
|
||||
"suitable for Python."
|
||||
msgstr ""
|
||||
"Ce module implémente de nombreuses briques d':term:`itérateur`\\s inspirées "
|
||||
"par des constructions de APL, Haskell et SML. Toutes ont été retravaillées "
|
||||
"dans un format adéquat pour Python."
|
||||
|
||||
#: ../Doc/library/itertools.rst:20
|
||||
msgid ""
|
||||
|
@ -35,6 +40,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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:25
|
||||
msgid ""
|
||||
|
@ -42,6 +51,10 @@ msgid ""
|
|||
"a sequence ``f(0), f(1), ...``. The same effect can be achieved in Python "
|
||||
"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 "
|
||||
"Python en combinant :func:`map` et :func;`count` pour former ``map(f, "
|
||||
"count())``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:29
|
||||
msgid ""
|
||||
|
@ -50,10 +63,14 @@ 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 :mode:`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:**"
|
||||
msgstr ""
|
||||
msgstr "**Itérateurs infinis :**"
|
||||
|
||||
#: ../Doc/library/itertools.rst:38 ../Doc/library/itertools.rst:48
|
||||
#: ../Doc/library/itertools.rst:67
|
||||
|
@ -63,7 +80,7 @@ msgstr "Itérateur"
|
|||
#: ../Doc/library/itertools.rst:38 ../Doc/library/itertools.rst:48
|
||||
#: ../Doc/library/itertools.rst:67
|
||||
msgid "Arguments"
|
||||
msgstr ""
|
||||
msgstr "Arguments"
|
||||
|
||||
#: ../Doc/library/itertools.rst:38 ../Doc/library/itertools.rst:48
|
||||
#: ../Doc/library/itertools.rst:67
|
||||
|
@ -80,11 +97,11 @@ msgstr ":func:`count`"
|
|||
|
||||
#: ../Doc/library/itertools.rst:40
|
||||
msgid "start, [step]"
|
||||
msgstr ""
|
||||
msgstr "start, [step]"
|
||||
|
||||
#: ../Doc/library/itertools.rst:40
|
||||
msgid "start, start+step, start+2*step, ..."
|
||||
msgstr ""
|
||||
msgstr "start, start+step, start+2*step, ..."
|
||||
|
||||
#: ../Doc/library/itertools.rst:40
|
||||
msgid "``count(10) --> 10 11 12 13 14 ...``"
|
||||
|
@ -116,7 +133,7 @@ msgstr "elem [,n]"
|
|||
|
||||
#: ../Doc/library/itertools.rst:42
|
||||
msgid "elem, elem, elem, ... endlessly or up to n times"
|
||||
msgstr ""
|
||||
msgstr "*elem*, *elem*, *elem*, ...à l'infini ou jusqu'à n fois"
|
||||
|
||||
#: ../Doc/library/itertools.rst:42
|
||||
msgid "``repeat(10, 3) --> 10 10 10``"
|
||||
|
@ -124,7 +141,7 @@ msgstr "``repeat(10, 3) --> 10 10 10``"
|
|||
|
||||
#: ../Doc/library/itertools.rst:45
|
||||
msgid "**Iterators terminating on the shortest input sequence:**"
|
||||
msgstr ""
|
||||
msgstr "**Itérateurs se terminant par la séquence d'entrée la plus courte :**"
|
||||
|
||||
#: ../Doc/library/itertools.rst:50
|
||||
msgid ":func:`accumulate`"
|
||||
|
@ -197,7 +214,7 @@ msgstr "pred, seq"
|
|||
|
||||
#: ../Doc/library/itertools.rst:54
|
||||
msgid "seq[n], seq[n+1], starting when pred fails"
|
||||
msgstr "seq[n], seq[n+1], starting when pred fails"
|
||||
msgstr "seq[n], seq[n+1], commençant quand *pred* échoue"
|
||||
|
||||
#: ../Doc/library/itertools.rst:54
|
||||
msgid "``dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1``"
|
||||
|
@ -209,7 +226,7 @@ msgstr ":func:`filterfalse`"
|
|||
|
||||
#: ../Doc/library/itertools.rst:55
|
||||
msgid "elements of seq where pred(elem) is false"
|
||||
msgstr " of seq where pred(elem) is false"
|
||||
msgstr " éléments de *seq* quand *pred(elem)* est faux"
|
||||
|
||||
#: ../Doc/library/itertools.rst:55
|
||||
msgid "``filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8``"
|
||||
|
@ -225,7 +242,7 @@ msgstr "iterable[, keyfunc]"
|
|||
|
||||
#: ../Doc/library/itertools.rst:56
|
||||
msgid "sub-iterators grouped by value of keyfunc(v)"
|
||||
msgstr ""
|
||||
msgstr "sous-itérateurs groupés par la valeur de *keyfunc(v)*"
|
||||
|
||||
#: ../Doc/library/itertools.rst:57
|
||||
msgid ":func:`islice`"
|
||||
|
@ -237,7 +254,7 @@ msgstr "seq, [start,] stop [, step]"
|
|||
|
||||
#: ../Doc/library/itertools.rst:57
|
||||
msgid "elements from seq[start:stop:step]"
|
||||
msgstr ""
|
||||
msgstr "éléments de seq[start:stop:step]"
|
||||
|
||||
#: ../Doc/library/itertools.rst:57
|
||||
msgid "``islice('ABCDEFG', 2, None) --> C D E F G``"
|
||||
|
@ -265,7 +282,7 @@ msgstr ":func:`takewhile`"
|
|||
|
||||
#: ../Doc/library/itertools.rst:59
|
||||
msgid "seq[0], seq[1], until pred fails"
|
||||
msgstr ""
|
||||
msgstr "seq[0], seq[1], jusqu'à ce que *pred* échoue"
|
||||
|
||||
#: ../Doc/library/itertools.rst:59
|
||||
msgid "``takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4``"
|
||||
|
@ -281,7 +298,7 @@ msgstr "it, n"
|
|||
|
||||
#: ../Doc/library/itertools.rst:60
|
||||
msgid "it1, it2, ... itn splits one iterator into n"
|
||||
msgstr ""
|
||||
msgstr "*it1*, *it2*, ... *itn* sépare un itérateur en *n*"
|
||||
|
||||
#: ../Doc/library/itertools.rst:61
|
||||
msgid ":func:`zip_longest`"
|
||||
|
@ -297,7 +314,7 @@ msgstr "``zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-``"
|
|||
|
||||
#: ../Doc/library/itertools.rst:64
|
||||
msgid "**Combinatoric generators:**"
|
||||
msgstr ""
|
||||
msgstr "**Générateurs combinatoires : **"
|
||||
|
||||
#: ../Doc/library/itertools.rst:69
|
||||
msgid ":func:`product`"
|
||||
|
@ -309,7 +326,7 @@ msgstr "p, q, ... [repeat=1]"
|
|||
|
||||
#: ../Doc/library/itertools.rst:69
|
||||
msgid "cartesian product, equivalent to a nested for-loop"
|
||||
msgstr ""
|
||||
msgstr "produit cartésien, équivalent à une boucle *for* imbriquée"
|
||||
|
||||
#: ../Doc/library/itertools.rst:70
|
||||
msgid ":func:`permutations`"
|
||||
|
@ -322,6 +339,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"
|
||||
|
||||
#: ../Doc/library/itertools.rst:71
|
||||
msgid ":func:`combinations`"
|
||||
|
@ -333,7 +352,7 @@ msgstr "p, r"
|
|||
|
||||
#: ../Doc/library/itertools.rst:71
|
||||
msgid "r-length tuples, in sorted order, no repeated elements"
|
||||
msgstr ""
|
||||
msgstr "tuples de longueur r, triés, sans répétition d'éléments"
|
||||
|
||||
#: ../Doc/library/itertools.rst:72
|
||||
msgid ":func:`combinations_with_replacement`"
|
||||
|
@ -341,7 +360,7 @@ msgstr ":func:`combinations_with_replacement`"
|
|||
|
||||
#: ../Doc/library/itertools.rst:72
|
||||
msgid "r-length tuples, in sorted order, with repeated elements"
|
||||
msgstr ""
|
||||
msgstr "tuples de longueur r, triés, avec répétition d'éléments"
|
||||
|
||||
#: ../Doc/library/itertools.rst:73
|
||||
msgid "``product('ABCD', repeat=2)``"
|
||||
|
@ -377,7 +396,7 @@ msgstr "``AA AB AC AD BB BC BD CC CD DD``"
|
|||
|
||||
#: ../Doc/library/itertools.rst:83
|
||||
msgid "Itertool functions"
|
||||
msgstr ""
|
||||
msgstr "Fonctions d'*itertool*"
|
||||
|
||||
#: ../Doc/library/itertools.rst:85
|
||||
msgid ""
|
||||
|
@ -385,6 +404,10 @@ 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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:91
|
||||
msgid ""
|
||||
|
@ -397,12 +420,21 @@ msgid ""
|
|||
"`~fractions.Fraction`.) If the input iterable is empty, the output iterable "
|
||||
"will also be empty."
|
||||
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é, it 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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:101 ../Doc/library/itertools.rst:193
|
||||
#: ../Doc/library/itertools.rst:242 ../Doc/library/itertools.rst:468
|
||||
#: ../Doc/library/itertools.rst:547 ../Doc/library/itertools.rst:600
|
||||
msgid "Roughly equivalent to::"
|
||||
msgstr ""
|
||||
msgstr "Sensiblement équivalent à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:117
|
||||
msgid ""
|
||||
|
@ -414,16 +446,26 @@ 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* ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:147
|
||||
msgid ""
|
||||
"See :func:`functools.reduce` for a similar function that returns only the "
|
||||
"final accumulated value."
|
||||
msgstr ""
|
||||
"Voir :func:`functools.reduce` pour une fonction similaire qui ne renvoie que "
|
||||
"la valeur accumulée finale."
|
||||
|
||||
#: ../Doc/library/itertools.rst:152
|
||||
msgid "Added the optional *func* parameter."
|
||||
msgstr ""
|
||||
msgstr "Le paramètre optionnel *func* a été ajouté."
|
||||
|
||||
#: ../Doc/library/itertools.rst:157
|
||||
msgid ""
|
||||
|
@ -432,16 +474,23 @@ 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 "
|
||||
"é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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:171
|
||||
msgid ""
|
||||
"Alternate constructor for :func:`chain`. Gets chained inputs from a single "
|
||||
"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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:183
|
||||
msgid "Return *r* length subsequences of elements from the input *iterable*."
|
||||
msgstr ""
|
||||
msgstr "Renvoyer les sous-séquences de longueur *r* de l'itérable *iterable*."
|
||||
|
||||
#: ../Doc/library/itertools.rst:185 ../Doc/library/itertools.rst:234
|
||||
msgid ""
|
||||
|
@ -449,6 +498,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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:189
|
||||
msgid ""
|
||||
|
@ -456,6 +508,9 @@ msgid ""
|
|||
"So if the input elements are unique, there will be no repeat values in each "
|
||||
"combination."
|
||||
msgstr ""
|
||||
"Les éléments sont considérés comme uniques en fonction de leur position, et "
|
||||
"non pas de leur valeur. Ainsi, si les éléments en entrée sont uniques, il "
|
||||
"n'y aura pas de valeurs répétées dans chaque combinaison."
|
||||
|
||||
#: ../Doc/library/itertools.rst:215
|
||||
msgid ""
|
||||
|
@ -463,18 +518,26 @@ 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) ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:226
|
||||
msgid ""
|
||||
"The number of items returned is ``n! / r! / (n-r)!`` when ``0 <= r <= n`` or "
|
||||
"zero when ``r > n``."
|
||||
msgstr ""
|
||||
"Le nombre d'éléments renvoyés est ``n! / r! / (n-r)!`` quand ``0 <= r <= n`` "
|
||||
"ou zéro quand ``r > n``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:231
|
||||
msgid ""
|
||||
"Return *r* length subsequences of elements from the input *iterable* "
|
||||
"allowing individual elements to be repeated more than once."
|
||||
msgstr ""
|
||||
"Renvoyer les sous-séquences de longueur *r* des éléments de l'itérable "
|
||||
"*iterable* d'entrée, permettant aux éléments individuels d'être répétés plus "
|
||||
"d'une fois."
|
||||
|
||||
#: ../Doc/library/itertools.rst:238
|
||||
msgid ""
|
||||
|
@ -482,6 +545,9 @@ msgid ""
|
|||
"So if the input elements are unique, the generated combinations will also be "
|
||||
"unique."
|
||||
msgstr ""
|
||||
"Les éléments sont considérés comme uniques en fonction de leur position, et "
|
||||
"non pas de leur valeur.. Ainsi si les éléments d'entrée sont uniques, les "
|
||||
"combinaisons générées seront aussi uniques."
|
||||
|
||||
#: ../Doc/library/itertools.rst:261
|
||||
msgid ""
|
||||
|
@ -489,11 +555,16 @@ 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) ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:272
|
||||
msgid ""
|
||||
"The number of items returned is ``(n+r-1)! / r! / (n-1)!`` when ``n > 0``."
|
||||
msgstr ""
|
||||
"Le nombre d'éléments renvoyés est ``(n+r-1)! / r! / (n-1)!`` quand ``n > 0``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:279
|
||||
msgid ""
|
||||
|
@ -502,6 +573,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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:293
|
||||
msgid ""
|
||||
|
@ -510,6 +585,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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:305
|
||||
msgid ""
|
||||
|
@ -517,10 +596,15 @@ 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())``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:309
|
||||
msgid "Added *step* argument and allowed non-integer arguments."
|
||||
msgstr ""
|
||||
"Ajout de l'argument *step* et ajout du support pour les arguments non-"
|
||||
"entiers."
|
||||
|
||||
#: ../Doc/library/itertools.rst:314
|
||||
msgid ""
|
||||
|
@ -528,12 +612,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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:328
|
||||
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)."
|
||||
|
||||
#: ../Doc/library/itertools.rst:334
|
||||
msgid ""
|
||||
|
@ -542,6 +631,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 "
|
||||
"*aucune* sortie avant que le prédicat ne devienne faux, il peut donc avoir "
|
||||
"un temps de démarrage long. Sensiblement équivalent à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:351
|
||||
msgid ""
|
||||
|
@ -549,6 +642,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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:366
|
||||
msgid ""
|
||||
|
@ -558,6 +654,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 "
|
||||
"*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 "
|
||||
"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é."
|
||||
|
||||
#: ../Doc/library/itertools.rst:372
|
||||
msgid ""
|
||||
|
@ -567,6 +669,12 @@ msgid ""
|
|||
"the same key function). That behavior differs from SQL's GROUP BY which "
|
||||
"aggregates common elements regardless of their input order."
|
||||
msgstr ""
|
||||
"L'opération de :func:`groupby` est similaire au filtre ``uniq`` dans Unix. "
|
||||
"Elle génère un nouveau groupe à chaque fois que la valeur de la fonction "
|
||||
"*key* change (ce pourquoi il est souvent nécessaire d'avoir trié les données "
|
||||
"selon la même fonction de clé). Ce comportement est différent de celui de "
|
||||
"GROUP BY de SQL qui agrège les éléments sans prendre compte de leur ordre "
|
||||
"d'entrée."
|
||||
|
||||
#: ../Doc/library/itertools.rst:378
|
||||
msgid ""
|
||||
|
@ -575,10 +683,15 @@ msgid ""
|
|||
"`groupby` object is advanced, the previous group is no longer visible. So, "
|
||||
"if that data is needed later, it should be stored as a list::"
|
||||
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 ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:390
|
||||
msgid ":func:`groupby` is roughly equivalent to::"
|
||||
msgstr ""
|
||||
msgstr ":func:`groupby` est sensiblement équivalent à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:422
|
||||
msgid ""
|
||||
|
@ -593,23 +706,42 @@ 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érables sont sauté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 "
|
||||
"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 "
|
||||
"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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:448
|
||||
msgid ""
|
||||
"If *start* is ``None``, then iteration starts at zero. If *step* is "
|
||||
"``None``, then the step defaults to one."
|
||||
msgstr ""
|
||||
"Si *start* vaut ``None``, alors l'itération commence à zéro. Si *step* vaut "
|
||||
"``None``, alors le pas est à 1 par défaut."
|
||||
|
||||
#: ../Doc/library/itertools.rst:454
|
||||
msgid ""
|
||||
"Return successive *r* length permutations of elements in the *iterable*."
|
||||
msgstr ""
|
||||
"Renvoyer les permutations successives de longueur *r* des éléments de "
|
||||
"*iterable*."
|
||||
|
||||
#: ../Doc/library/itertools.rst:456
|
||||
msgid ""
|
||||
"If *r* is not specified or is ``None``, then *r* defaults to the length of "
|
||||
"the *iterable* and all possible full-length permutations are generated."
|
||||
msgstr ""
|
||||
"Si *r* n'est pas spécifié ou vaut ``None``, alors *r* a pour valeur la "
|
||||
"longueur de *iterable* et toutes les permutations de longueur *r* possibles "
|
||||
"sont générées."
|
||||
|
||||
#: ../Doc/library/itertools.rst:460
|
||||
msgid ""
|
||||
|
@ -617,6 +749,9 @@ msgid ""
|
|||
"*iterable* is sorted, the permutation tuples will be produced in sorted "
|
||||
"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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:464
|
||||
msgid ""
|
||||
|
@ -624,6 +759,9 @@ msgid ""
|
|||
"So if the input elements are unique, there will be no repeat values in each "
|
||||
"permutation."
|
||||
msgstr ""
|
||||
"Les éléments sont considérés comme uniques en fonction de leur position, et "
|
||||
"non pas de leur valeur. Ainsi, si l'élément est unique, il n'y aura pas de "
|
||||
"valeurs répétées dans chaque permutation."
|
||||
|
||||
#: ../Doc/library/itertools.rst:495
|
||||
msgid ""
|
||||
|
@ -631,16 +769,21 @@ 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) ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:507
|
||||
msgid ""
|
||||
"The number of items returned is ``n! / (n-r)!`` when ``0 <= r <= n`` or zero "
|
||||
"when ``r > n``."
|
||||
msgstr ""
|
||||
"Le nombre d'éléments renvoyés est ``n! / (n-r)!`` quand ``0 <= r <= n`` ou "
|
||||
"zéro quand ``r > n``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:512
|
||||
msgid "Cartesian product of input iterables."
|
||||
msgstr ""
|
||||
msgstr "Produit cartésien des itérables d'entrée."
|
||||
|
||||
#: ../Doc/library/itertools.rst:514
|
||||
msgid ""
|
||||
|
@ -648,6 +791,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)``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:517
|
||||
msgid ""
|
||||
|
@ -656,6 +802,10 @@ msgid ""
|
|||
"if the input's iterables are sorted, the product tuples are emitted in "
|
||||
"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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:522
|
||||
msgid ""
|
||||
|
@ -663,12 +813,17 @@ 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 "
|
||||
"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)``."
|
||||
|
||||
#: ../Doc/library/itertools.rst:526
|
||||
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 ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:542
|
||||
msgid ""
|
||||
|
@ -677,12 +832,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 "
|
||||
"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*."
|
||||
|
||||
#: ../Doc/library/itertools.rst:558
|
||||
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* ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:566
|
||||
msgid ""
|
||||
|
@ -693,16 +854,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 "
|
||||
"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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:580
|
||||
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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:594
|
||||
msgid "Return *n* independent iterators from a single iterable."
|
||||
msgstr ""
|
||||
msgstr "Renvoyer *n* itérateurs indépendant depuis un unique itérable."
|
||||
|
||||
#: ../Doc/library/itertools.rst:596
|
||||
msgid ""
|
||||
|
@ -710,6 +879,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)`)."
|
||||
|
||||
#: ../Doc/library/itertools.rst:617
|
||||
msgid ""
|
||||
|
@ -717,6 +889,9 @@ msgid ""
|
|||
"used anywhere else; otherwise, the *iterable* could get advanced without the "
|
||||
"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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:621
|
||||
msgid ""
|
||||
|
@ -725,6 +900,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`."
|
||||
|
||||
#: ../Doc/library/itertools.rst:629
|
||||
msgid ""
|
||||
|
@ -733,6 +913,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 "
|
||||
"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 à ::"
|
||||
|
||||
#: ../Doc/library/itertools.rst:654
|
||||
msgid ""
|
||||
|
@ -741,16 +925,22 @@ msgid ""
|
|||
"number of calls (for example :func:`islice` or :func:`takewhile`). If not "
|
||||
"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 "
|
||||
"d'appels (par exemple, :func:`islice` ou :func:`takewhile`). Si *fillvalue* "
|
||||
"n'est pas spécifié, il vaut ``None`` par défaut."
|
||||
|
||||
#: ../Doc/library/itertools.rst:663
|
||||
msgid "Itertools Recipes"
|
||||
msgstr ""
|
||||
msgstr "Recettes *itertools*"
|
||||
|
||||
#: ../Doc/library/itertools.rst:665
|
||||
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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:668
|
||||
msgid ""
|
||||
|
@ -762,6 +952,13 @@ msgid ""
|
|||
"preferring \"vectorized\" building blocks over the use of for-loops and :"
|
||||
"term:`generator`\\s which incur interpreter overhead."
|
||||
msgstr ""
|
||||
"Ces outils dérivés offrent la même bonne performance que les outils sous-"
|
||||
"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."
|
||||
|
||||
#: ../Doc/library/itertools.rst:861
|
||||
msgid ""
|
||||
|
@ -769,3 +966,7 @@ msgid ""
|
|||
"with local variables defined as default values. For example, the "
|
||||
"*dotproduct* recipe can be written as::"
|
||||
msgstr ""
|
||||
"Note, beaucoup des recettes ci-dessus peuvent être optimisées en replaçant "
|
||||
"les recherches globales par des recherches locales avec des variables "
|
||||
"locales définies comme des valeurs par défaut. Par exemple, la recette "
|
||||
"*dotproduct* peut être écrite comme ::"
|
||||
|
|
Loading…
Reference in New Issue