# 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-10-29 21:40+0100\n"

"PO-Revision-Date: 2021-10-17 12:13+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\n"

#: library/bisect.rst:2

#, fuzzy

msgid ":mod:`!bisect` --- Array bisection algorithm"

msgstr ":mod:`bisect` — Algorithme de bissection de listes"

#: library/bisect.rst:10

msgid "**Source code:** :source:`Lib/bisect.py`"

msgstr "**Code source :** :source:`Lib/bisect.py`"

#: library/bisect.rst:14

#, fuzzy

msgid ""

"This module provides support for maintaining a list in sorted order without "

"having to sort the list after each insertion. For long lists of items with "

"expensive comparison operations, this can be an improvement over linear "

"searches or frequent resorting."

msgstr ""

"Ce module fournit des outils pour maintenir une liste triée sans avoir à la "

"trier à chaque insertion. Il pourrait être plus rapide que l'approche "

"classique pour de longues listes d'éléments dont les opérations de "

"comparaison sont lourdes. Le module se nomme :mod:`bisect` car il utilise "

"une approche simple par bissection. Si vous voulez un exemple de cet "

"algorithme, le mieux est d'aller lire le code source de ce module (les "

"conditions sur les limites y étant justes !)."

#: library/bisect.rst:19

msgid ""

"The module is called :mod:`bisect` because it uses a basic bisection "

"algorithm to do its work. Unlike other bisection tools that search for a "

"specific value, the functions in this module are designed to locate an "

"insertion point. Accordingly, the functions never call an :meth:`~object."

"__eq__` method to determine whether a value has been found. Instead, the "

"functions only call the :meth:`~object.__lt__` method and will return an "

"insertion point between values in an array."

msgstr ""

#: library/bisect.rst:29

msgid "The following functions are provided:"

msgstr "Les fonctions suivantes sont fournies :"

#: library/bisect.rst:34

msgid ""

"Locate the insertion point for *x* in *a* to maintain sorted order. The "

"parameters *lo* and *hi* may be used to specify a subset of the list which "

"should be considered; by default the entire list is used. If *x* is already "

"present in *a*, the insertion point will be before (to the left of) any "

"existing entries. The return value is suitable for use as the first "

"parameter to ``list.insert()`` assuming that *a* is already sorted."

msgstr ""

"Trouve le point d'insertion de *x* dans *a* permettant de conserver l'ordre. "

"Les paramètres *lo* et *hi* permettent de limiter les emplacements à "

"vérifier dans la liste, par défaut toute la liste est utilisée. Si *x* est "

"déjà présent dans *a*, le point d'insertion proposé sera avant (à gauche) de "

"l'entrée existante. Si *a* est déjà triée, la valeur renvoyée peut "

"directement être utilisée comme premier paramètre de ``list.insert()``."

#: library/bisect.rst:41

#, fuzzy

msgid ""

"The returned insertion point *ip* partitions the array *a* into two slices "

"such that ``all(elem < x for elem in a[lo : ip])`` is true for the left "

"slice and ``all(elem >= x for elem in a[ip : hi])`` is true for the right "

"slice."

msgstr ""

"Le point d'insertion renvoyé, *i*, coupe la liste *a* en deux moitiés telles "

"que, pour la moitié de gauche : ``all(val < x for val in a[lo : i])``, et "

"pour la partie de droite : ``all(val >= x for val in a[i : hi])``."

#: library/bisect.rst:46

#, fuzzy

msgid ""

"*key* specifies a :term:`key function` of one argument that is used to "

"extract a comparison key from each element in the array. To support "

"searching complex records, the key function is not applied to the *x* value."

msgstr ""

"Le paramètre facultatif *key* est une :term:`fonction clé <key function>` "

"prenant un argument. S'il est fourni, les comparaisons se font sur les "

"valeurs renvoyées par la fonction clé. Par défaut, les éléments sont "

"comparés directement."

#: library/bisect.rst:50

msgid ""

"If *key* is ``None``, the elements are compared directly and no key function "

"is called."

msgstr ""

#: library/bisect.rst:67 library/bisect.rst:105

msgid "Added the *key* parameter."

msgstr "ajout du paramètre *key*."

#: library/bisect.rst:60

#, fuzzy

msgid ""

"Similar to :py:func:`~bisect.bisect_left`, but returns an insertion point "

"which comes after (to the right of) any existing entries of *x* in *a*."

msgstr ""

"Semblable à :func:`bisect_left`, mais renvoie un point d'insertion après (à "

"droite) d'une potentielle entrée existante valant *x* dans *a*."

#: library/bisect.rst:63

#, fuzzy

msgid ""

"The returned insertion point *ip* partitions the array *a* into two slices "

"such that ``all(elem <= x for elem in a[lo : ip])`` is true for the left "

"slice and ``all(elem > x for elem in a[ip : hi])`` is true for the right "

"slice."

msgstr ""

"Le point d'insertion renvoyé, *i*, coupe la liste *a* en deux moitiés telles "

"que, pour la moitié de gauche : ``all(val <= x for val in a[lo : i])`` et "

"pour la moitié de droite : ``all(val > x for val in a[i : hi])``."

#: library/bisect.rst:73

msgid "Insert *x* in *a* in sorted order."

msgstr "Insère *x* dans *a* en préservant l'ordre."

#: library/bisect.rst:75

#, fuzzy

msgid ""

"This function first runs :py:func:`~bisect.bisect_left` to locate an "

"insertion point. Next, it runs the :meth:`!insert` method on *a* to insert "

"*x* at the appropriate position to maintain sort order."

msgstr ""

"Cette fonction commence par appliquer :func:`bisect_left` pour déterminer la "

"position de l'insertion, puis appelle la méthode :meth:`insert` de *a* pour "

"ajouter *x* à l'endroit adéquat."

#: library/bisect.rst:99

msgid ""

"To support inserting records in a table, the *key* function (if any) is "

"applied to *x* for the search step but not for the insertion step."

msgstr ""

#: library/bisect.rst:102

#, fuzzy

msgid ""

"Keep in mind that the *O*\\ (log *n*) search is dominated by the slow *O*\\ "

"(*n*) insertion step."

msgstr ""

"Gardez à l'esprit que la complexité logarithmique :math:`O(\\ln(n))` de la "

"recherche est dominée par la lenteur de l'insertion, de complexité linéaire :"

"math:`O(n)`."

#: library/bisect.rst:92

#, fuzzy

msgid ""

"Similar to :py:func:`~bisect.insort_left`, but inserting *x* in *a* after "

"any existing entries of *x*."

msgstr ""

"Similaire à :func:`insort_left`, mais en insérant *x* dans *a* après une "

"potentielle entrée existante égale à *x*."

#: library/bisect.rst:95

#, fuzzy

msgid ""

"This function first runs :py:func:`~bisect.bisect_right` to locate an "

"insertion point. Next, it runs the :meth:`!insert` method on *a* to insert "

"*x* at the appropriate position to maintain sort order."

msgstr ""

"Le principe est le même que :func:`insort_left`, mais avec :func:"

"`bisect_right`."

#: library/bisect.rst:110

msgid "Performance Notes"

msgstr "Notes sur la performance"

#: library/bisect.rst:112

msgid ""

"When writing time sensitive code using *bisect()* and *insort()*, keep these "

"thoughts in mind:"

msgstr ""

"Pour écrire du code sensible à la performance utilisant ``bisect()`` et "

"``insort()``, prenez en compte ces quelques considérations :"

#: library/bisect.rst:115

msgid ""

"Bisection is effective for searching ranges of values. For locating specific "

"values, dictionaries are more performant."

msgstr ""

"La bissection est une bonne idée pour rechercher une plage de valeurs. Pour "

"une seule valeur, mieux vaut un dictionnaire."

#: library/bisect.rst:118

#, fuzzy

msgid ""

"The *insort()* functions are *O*\\ (*n*) because the logarithmic search step "

"is dominated by the linear time insertion step."

msgstr ""

"Les fonctions d'insertion dans une liste classée ont une complexité linéaire "

"car c'est le coût d'une insertion, même si la recherche est logarithmique."

#: library/bisect.rst:121

#, fuzzy

msgid ""

"The search functions are stateless and discard key function results after "

"they are used. Consequently, if the search functions are used in a loop, "

"the key function may be called again and again on the same array elements. "

"If the key function isn't fast, consider wrapping it with :py:func:"

"`functools.cache` to avoid duplicate computations. Alternatively, consider "

"searching an array of precomputed keys to locate the insertion point (as "

"shown in the examples section below)."

msgstr ""

"Les fonctions de recherche ne maintiennent pas d'état et ne conservent pas "

"le résultat de la fonction clé après utilisation. Par conséquent, si elles "

"sont appelées dans une boucle, la fonction clé peut être appelée de "

"nombreuses fois sur les mêmes entrées. Si cette fonction clé est lente, une "

"possibilité est de l'encapsuler dans :func:`functools.cache` pour éviter de "

"répéter les opérations. Une autre possibilité est d'effectuer la recherche "

"sur un tableau de clés pré-calculées pour trouver le point d'insertion (voir "

"les exemples plus bas)."

#: library/bisect.rst:131

#, fuzzy

msgid ""

"`Sorted Collections <https://grantjenks.com/docs/sortedcollections/>`_ is a "

"high performance module that uses *bisect* to managed sorted collections of "

"data."

msgstr ""

"`Sorted Collections <http://www.grantjenks.com/docs/sortedcollections/>`_ "

"est un module de haute performance qui fait appel à *bisect* pour maintenir "

"des données ordonnées."

#: library/bisect.rst:135

msgid ""

"The `SortedCollection recipe <https://code.activestate.com/recipes/577197-"

"sortedcollection/>`_ uses bisect to build a full-featured collection class "

"with straight-forward search methods and support for a key-function. The "

"keys are precomputed to save unnecessary calls to the key function during "

"searches."

msgstr ""

"`SortedCollection recipe <https://code.activestate.com/recipes/577197-"

"sortedcollection/>`_ utilise le module *bisect* pour construire une classe "

"collection exposant des méthodes de recherches naturelles et gérant une "

"fonction clef. Les clefs sont pré-calculées pour économiser des appels "

"inutiles à la fonction clef durant les recherches."

#: library/bisect.rst:143

msgid "Searching Sorted Lists"

msgstr "Chercher dans des listes triées"

#: library/bisect.rst:145

#, fuzzy

msgid ""

"The above `bisect functions`_ are useful for finding insertion points but "

"can be tricky or awkward to use for common searching tasks. The following "

"five functions show how to transform them into the standard lookups for "

"sorted lists::"

msgstr ""

"Les fonctions :func:`bisect` ci-dessus sont utiles pour insérer des "

"éléments, mais peuvent être étranges et peu naturelles à utiliser pour "

"rechercher des éléments. Les cinq fonctions suivantes montrent comment les "

"transformer en recherche plus classique pour les listes triées ::"

#: library/bisect.rst:150

msgid ""

"def index(a, x):\n"

" 'Locate the leftmost value exactly equal to x'\n"

" i = bisect_left(a, x)\n"

" if i != len(a) and a[i] == x:\n"

" return i\n"

" raise ValueError\n"

"\n"

"def find_lt(a, x):\n"

" 'Find rightmost value less than x'\n"

" i = bisect_left(a, x)\n"

" if i:\n"

" return a[i-1]\n"

" raise ValueError\n"

"\n"

"def find_le(a, x):\n"

" 'Find rightmost value less than or equal to x'\n"

" i = bisect_right(a, x)\n"

" if i:\n"

" return a[i-1]\n"

" raise ValueError\n"

"\n"

"def find_gt(a, x):\n"

" 'Find leftmost value greater than x'\n"

" i = bisect_right(a, x)\n"

" if i != len(a):\n"

" return a[i]\n"

" raise ValueError\n"

"\n"

"def find_ge(a, x):\n"

" 'Find leftmost item greater than or equal to x'\n"

" i = bisect_left(a, x)\n"

" if i != len(a):\n"

" return a[i]\n"

" raise ValueError"

msgstr ""

#: library/bisect.rst:187

msgid "Examples"

msgstr "Exemples"

#: library/bisect.rst:191

#, fuzzy

msgid ""

"The :py:func:`~bisect.bisect` function can be useful for numeric table "

"lookups. This example uses :py:func:`~bisect.bisect` to look up a letter "

"grade for an exam score (say) based on a set of ordered numeric breakpoints: "

"90 and up is an 'A', 80 to 89 is a 'B', and so on::"

msgstr ""

"La fonction :func:`bisect` peut être utile pour des recherches dans des "

"tableaux de nombres. Cet exemple utilise :func:`bisect` pour rechercher la "

"note (sous forme de lettre) correspondant à une note sous forme de points, "

"en se basant sur une échelle prédéfinie : plus de 90 vaut 'A', de 80 à 89 "

"vaut 'B', etc ::"

#: library/bisect.rst:196

msgid ""

">>> def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):\n"

"... i = bisect(breakpoints, score)\n"

"... return grades[i]\n"

"...\n"

">>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]\n"

"['F', 'A', 'C', 'C', 'B', 'A', 'A']"

msgstr ""

#: library/bisect.rst:203

msgid ""

"The :py:func:`~bisect.bisect` and :py:func:`~bisect.insort` functions also "

"work with lists of tuples. The *key* argument can serve to extract the "

"field used for ordering records in a table::"

msgstr ""

#: library/bisect.rst:207

msgid ""

">>> from collections import namedtuple\n"

">>> from operator import attrgetter\n"

">>> from bisect import bisect, insort\n"

">>> from pprint import pprint\n"

"\n"

">>> Movie = namedtuple('Movie', ('name', 'released', 'director'))\n"

"\n"

">>> movies = [\n"

"... Movie('Jaws', 1975, 'Spielberg'),\n"

"... Movie('Titanic', 1997, 'Cameron'),\n"

"... Movie('The Birds', 1963, 'Hitchcock'),\n"

"... Movie('Aliens', 1986, 'Cameron')\n"

"... ]\n"

"\n"

">>> # Find the first movie released after 1960\n"

">>> by_year = attrgetter('released')\n"

">>> movies.sort(key=by_year)\n"

">>> movies[bisect(movies, 1960, key=by_year)]\n"

"Movie(name='The Birds', released=1963, director='Hitchcock')\n"

"\n"

">>> # Insert a movie while maintaining sort order\n"

">>> romance = Movie('Love Story', 1970, 'Hiller')\n"

">>> insort(movies, romance, key=by_year)\n"

">>> pprint(movies)\n"

"[Movie(name='The Birds', released=1963, director='Hitchcock'),\n"

" Movie(name='Love Story', released=1970, director='Hiller'),\n"

" Movie(name='Jaws', released=1975, director='Spielberg'),\n"

" Movie(name='Aliens', released=1986, director='Cameron'),\n"

" Movie(name='Titanic', released=1997, director='Cameron')]"

msgstr ""

#: library/bisect.rst:237

#, fuzzy

msgid ""

"If the key function is expensive, it is possible to avoid repeated function "

"calls by searching a list of precomputed keys to find the index of a record::"

msgstr ""

"Une technique consiste à utiliser une liste de clefs pré-calculée pour "

"chercher l'indice de l'enregistrement en question ::"

#: library/bisect.rst:240

msgid ""

">>> data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)]\n"

">>> data.sort(key=lambda r: r[1]) # Or use operator.itemgetter(1).\n"

">>> keys = [r[1] for r in data] # Precompute a list of keys.\n"

">>> data[bisect_left(keys, 0)]\n"

"('black', 0)\n"

">>> data[bisect_left(keys, 1)]\n"

"('blue', 1)\n"

">>> data[bisect_left(keys, 5)]\n"

"('red', 5)\n"

">>> data[bisect_left(keys, 8)]\n"

"('yellow', 8)"

msgstr ""

#~ msgid ""

#~ "Insert *x* in *a* in sorted order. This is equivalent to ``a."

#~ "insert(bisect.bisect_left(a, x, lo, hi), x)`` assuming that *a* is "

#~ "already sorted. Keep in mind that the O(log n) search is dominated by "

#~ "the slow O(n) insertion step."

#~ msgstr ""

#~ "Insère *x* dans *a* en conservant le tri. C'est l'équivalent de ``a."

#~ "insert(bisect.bisect_left(a, x, lo, hi), x)``, tant que *a* est déjà "

#~ "triée. Gardez en tête que bien que la recherche ne coûte que O(log n), "

#~ "l'insertion coûte O(n)."

#~ msgid ""

#~ "Unlike the :func:`sorted` function, it does not make sense for the :func:"

#~ "`bisect` functions to have *key* or *reversed* arguments because that "

#~ "would lead to an inefficient design (successive calls to bisect functions "

#~ "would not \"remember\" all of the previous key lookups)."

#~ msgstr ""

#~ "Contrairement à la fonction :func:`sorted`, ça n'aurait pas de sens pour "

#~ "la fonction :func:`bisect` d'avoir un paramètre *key* ou *reversed*, qui "

#~ "conduiraient à une utilisation inefficace (des appels successifs à la "

#~ "fonction *bisect* n'auraient aucun moyen de se \"souvenir\" des "

#~ "recherches de clef précédentes)."