forked from AFPy/python-docs-fr
302 lines
13 KiB
Plaintext
302 lines
13 KiB
Plaintext
# 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: 2022-05-22 23:13+0200\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
|
||
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
|
||
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 the more "
|
||
"common approach. The module is called :mod:`bisect` because it uses a basic "
|
||
"bisection algorithm to do its work. The source code may be most useful as a "
|
||
"working example of the algorithm (the boundary conditions are already "
|
||
"right!)."
|
||
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:21
|
||
msgid "The following functions are provided:"
|
||
msgstr "Les fonctions suivantes sont fournies :"
|
||
|
||
#: library/bisect.rst:26
|
||
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:33
|
||
msgid ""
|
||
"The returned insertion point *i* partitions the array *a* into two halves so "
|
||
"that ``all(val < x for val in a[lo : i])`` for the left side and ``all(val "
|
||
">= x for val in a[i : hi])`` for the right side."
|
||
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:58
|
||
#, 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:62
|
||
msgid ""
|
||
"If *key* is ``None``, the elements are compared directly with no intervening "
|
||
"function call."
|
||
msgstr ""
|
||
|
||
#: library/bisect.rst:65 library/bisect.rst:103
|
||
msgid "Added the *key* parameter."
|
||
msgstr "ajout du paramètre *key*."
|
||
|
||
#: library/bisect.rst:51
|
||
msgid ""
|
||
"Similar to :func:`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:54
|
||
msgid ""
|
||
"The returned insertion point *i* partitions the array *a* into two halves so "
|
||
"that ``all(val <= x for val in a[lo : i])`` for the left side and ``all(val "
|
||
"> x for val in a[i : hi])`` for the right side."
|
||
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:71
|
||
msgid "Insert *x* in *a* in sorted order."
|
||
msgstr "Insère *x* dans *a* en préservant l'ordre."
|
||
|
||
#: library/bisect.rst:73
|
||
msgid ""
|
||
"This function first runs :func:`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:97
|
||
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:100
|
||
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:90
|
||
msgid ""
|
||
"Similar to :func:`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:93
|
||
msgid ""
|
||
"This function first runs :func:`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:108
|
||
msgid "Performance Notes"
|
||
msgstr "Notes sur la performance"
|
||
|
||
#: library/bisect.rst:110
|
||
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:113
|
||
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:116
|
||
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:119
|
||
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 :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:129
|
||
msgid ""
|
||
"`Sorted Collections <http://www.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:133
|
||
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:141
|
||
msgid "Searching Sorted Lists"
|
||
msgstr "Chercher dans des listes triées"
|
||
|
||
#: library/bisect.rst:143
|
||
msgid ""
|
||
"The above :func:`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:185
|
||
msgid "Examples"
|
||
msgstr "Exemples"
|
||
|
||
#: library/bisect.rst:189
|
||
msgid ""
|
||
"The :func:`bisect` function can be useful for numeric table lookups. This "
|
||
"example uses :func:`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:201
|
||
msgid ""
|
||
"The :func:`bisect` and :func:`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:235
|
||
#, 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 ::"
|
||
|
||
#~ 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)."
|