# 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: 2023-01-23 09:57+0100\n" "PO-Revision-Date: 2022-07-26 02:23+0200\n" "Last-Translator: Philippe GALVAN \n" "Language-Team: FRENCH \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.1.1\n" #: library/random.rst:2 msgid ":mod:`random` --- Generate pseudo-random numbers" msgstr ":mod:`random` --- Génère des nombres pseudo-aléatoires" #: library/random.rst:7 msgid "**Source code:** :source:`Lib/random.py`" msgstr "**Code source :** :source:`Lib/random.py`" #: library/random.rst:11 msgid "" "This module implements pseudo-random number generators for various " "distributions." msgstr "" "Ce module implémente des générateurs de nombres pseudo-aléatoires pour " "différentes distributions." #: library/random.rst:14 msgid "" "For integers, there is uniform selection from a range. For sequences, there " "is uniform selection of a random element, a function to generate a random " "permutation of a list in-place, and a function for random sampling without " "replacement." msgstr "" "Pour les entiers, il existe une sélection uniforme à partir d'une plage. " "Pour les séquences, il existe une sélection uniforme d'un élément aléatoire, " "une fonction pour générer une permutation aléatoire d'une liste sur place et " "une fonction pour un échantillonnage aléatoire sans remplacement." #: library/random.rst:19 msgid "" "On the real line, there are functions to compute uniform, normal (Gaussian), " "lognormal, negative exponential, gamma, and beta distributions. For " "generating distributions of angles, the von Mises distribution is available." msgstr "" "Pour l'ensemble des réels, il y a des fonctions pour calculer des " "distributions uniformes, normales (gaussiennes), log-normales, " "exponentielles négatives, gamma et bêta. Pour générer des distributions " "d'angles, la distribution de *von Mises* est disponible." #: library/random.rst:23 #, fuzzy msgid "" "Almost all module functions depend on the basic function :func:`.random`, " "which generates a random float uniformly in the half-open range ``0.0 <= X < " "1.0``. Python uses the Mersenne Twister as the core generator. It produces " "53-bit precision floats and has a period of 2\\*\\*19937-1. The underlying " "implementation in C is both fast and threadsafe. The Mersenne Twister is " "one of the most extensively tested random number generators in existence. " "However, being completely deterministic, it is not suitable for all " "purposes, and is completely unsuitable for cryptographic purposes." msgstr "" "Presque toutes les fonctions du module dépendent de la fonction de base :" "func:`.random`, qui génère un nombre à virgule flottante aléatoire de façon " "uniforme dans la plage semi-ouverte [0.0, 1.0). Python utilise l'algorithme " "*Mersenne Twister* comme générateur de base. Il produit des flottants de " "précision de 53 bits et a une période de 2\\*\\*19937-1. L'implémentation " "sous-jacente en C est à la fois rapide et compatible avec les programmes " "ayant de multiples fils d'exécution. Le *Mersenne Twister* est l'un des " "générateurs de nombres aléatoires les plus largement testés qui existent. " "Cependant, étant complètement déterministe, il n'est pas adapté à tous les " "usages et est totalement inadapté à des fins cryptographiques." #: library/random.rst:32 msgid "" "The functions supplied by this module are actually bound methods of a hidden " "instance of the :class:`random.Random` class. You can instantiate your own " "instances of :class:`Random` to get generators that don't share state." msgstr "" "Les fonctions fournies par ce module dépendent en réalité de méthodes d’une " "instance cachée de la classe :class:`random.Random`. Vous pouvez créer vos " "propres instances de :class:`Random` pour obtenir des générateurs sans états " "partagés." #: library/random.rst:36 msgid "" "Class :class:`Random` can also be subclassed if you want to use a different " "basic generator of your own devising: in that case, override the :meth:" "`~Random.random`, :meth:`~Random.seed`, :meth:`~Random.getstate`, and :meth:" "`~Random.setstate` methods. Optionally, a new generator can supply a :meth:" "`~Random.getrandbits` method --- this allows :meth:`randrange` to produce " "selections over an arbitrarily large range." msgstr "" "La classe :class:`Random` peut également être sous-classée si vous voulez " "utiliser un générateur de base différent, de votre propre conception. Dans " "ce cas, remplacez les méthodes :meth:`~Random.random`, :meth:`~Random." "seed`, :meth:`~Random.gettsate` et :meth:`~Random.setstate`. En option, un " "nouveau générateur peut fournir une méthode :meth:`~Random.getrandbits` --- " "ce qui permet à :meth:`randrange` de produire des sélections sur une plage " "de taille arbitraire." #: library/random.rst:42 msgid "" "The :mod:`random` module also provides the :class:`SystemRandom` class which " "uses the system function :func:`os.urandom` to generate random numbers from " "sources provided by the operating system." msgstr "" "Le module :mod:`random` fournit également la classe :class:`SystemRandom` " "qui utilise la fonction système :func:`os.urandom` pour générer des nombres " "aléatoires à partir de sources fournies par le système d'exploitation." #: library/random.rst:48 msgid "" "The pseudo-random generators of this module should not be used for security " "purposes. For security or cryptographic uses, see the :mod:`secrets` module." msgstr "" "Les générateurs pseudo-aléatoires de ce module ne doivent pas être utilisés " "à des fins de sécurité. Pour des utilisations de sécurité ou " "cryptographiques, voir le module :mod:`secrets`." #: library/random.rst:54 msgid "" "M. Matsumoto and T. Nishimura, \"Mersenne Twister: A 623-dimensionally " "equidistributed uniform pseudorandom number generator\", ACM Transactions on " "Modeling and Computer Simulation Vol. 8, No. 1, January pp.3--30 1998." msgstr "" "*M. Matsumoto and T. Nishimura, \"Mersenne Twister: A 623-dimensionally " "equidistributed uniform pseudorandom number generator\", ACM Transactions on " "Modeling and Computer Simulation Vol. 8, No. 1,* Janvier pp.3--30 1998." #: library/random.rst:59 msgid "" "`Complementary-Multiply-with-Carry recipe `_ for a compatible alternative random number generator with " "a long period and comparatively simple update operations." msgstr "" "`Complementary-Multiply-with-Carry recipe `_ pour un autre générateur de nombres aléatoires avec une " "longue période et des opérations de mise à jour relativement simples." #: library/random.rst:66 msgid "Bookkeeping functions" msgstr "Fonctions de gestion d'état" #: library/random.rst:70 msgid "Initialize the random number generator." msgstr "Initialise le générateur de nombres aléatoires." #: library/random.rst:72 msgid "" "If *a* is omitted or ``None``, the current system time is used. If " "randomness sources are provided by the operating system, they are used " "instead of the system time (see the :func:`os.urandom` function for details " "on availability)." msgstr "" "Si *a* est omis ou ``None``, l'heure système actuelle est utilisée. Si des " "sources aléatoires sont fournies par le système d'exploitation, elles sont " "utilisées à la place de l'heure système (voir la fonction :func:`os.urandom` " "pour les détails sur la disponibilité)." #: library/random.rst:77 msgid "If *a* is an int, it is used directly." msgstr "Si *a* est un entier, il est utilisé directement." #: library/random.rst:79 msgid "" "With version 2 (the default), a :class:`str`, :class:`bytes`, or :class:" "`bytearray` object gets converted to an :class:`int` and all of its bits are " "used." msgstr "" "Avec la version 2 (par défaut), un objet :class:`str`, :class:`bytes` ou :" "class:`bytearray` est converti en :class:`int` et tous ses bits sont " "utilisés." #: library/random.rst:82 msgid "" "With version 1 (provided for reproducing random sequences from older " "versions of Python), the algorithm for :class:`str` and :class:`bytes` " "generates a narrower range of seeds." msgstr "" "Avec la version 1 (fournie pour reproduire des séquences aléatoires " "produites par d'anciennes versions de Python), l'algorithme pour :class:" "`str` et :class:`bytes` génère une gamme plus étroite de graines." #: library/random.rst:86 msgid "" "Moved to the version 2 scheme which uses all of the bits in a string seed." msgstr "" "Passée à la version 2 du schéma qui utilise tous les bits d'une graine de " "chaîne de caractères." #: library/random.rst:89 #, fuzzy msgid "" "The *seed* must be one of the following types: *NoneType*, :class:`int`, :" "class:`float`, :class:`str`, :class:`bytes`, or :class:`bytearray`." msgstr "" "À l’avenir, la *graine* devra être de l’un des types suivants : *NoneType*, :" "class:`int`, :class:`float`, :class:`str`, :class:`bytes` ou :class:" "`bytearray`." #: library/random.rst:96 msgid "" "Return an object capturing the current internal state of the generator. " "This object can be passed to :func:`setstate` to restore the state." msgstr "" "Renvoie un objet capturant l'état interne actuel du générateur. Cet objet " "peut être passé à :func:`setstate` pour restaurer cet état." #: library/random.rst:102 msgid "" "*state* should have been obtained from a previous call to :func:`getstate`, " "and :func:`setstate` restores the internal state of the generator to what it " "was at the time :func:`getstate` was called." msgstr "" "Il convient que *state* ait été obtenu à partir d'un appel précédent à :func:" "`getstate`, et :func:`setstate` restaure l'état interne du générateur à ce " "qu'il était au moment où :func:`getstate` a été appelé." #: library/random.rst:108 msgid "Functions for bytes" msgstr "Fonctions pour les octets" #: library/random.rst:112 msgid "Generate *n* random bytes." msgstr "Génère *n* octets aléatoires." #: library/random.rst:114 msgid "" "This method should not be used for generating security tokens. Use :func:" "`secrets.token_bytes` instead." msgstr "" "Cette méthode ne doit pas être utilisée pour générer des jetons de sécurité. " "Utiliser :func:`secrets.token_bytes` à la place." #: library/random.rst:121 msgid "Functions for integers" msgstr "Fonctions pour les entiers" #: library/random.rst:126 msgid "" "Return a randomly selected element from ``range(start, stop, step)``. This " "is equivalent to ``choice(range(start, stop, step))``, but doesn't actually " "build a range object." msgstr "" "Renvoie un élément sélectionné aléatoirement à partir de ``range(start, " "stop, step)``. C'est équivalent à ``choice(range(start, stop, step))``, " "mais ne construit pas réellement un objet range." #: library/random.rst:130 msgid "" "The positional argument pattern matches that of :func:`range`. Keyword " "arguments should not be used because the function may use them in unexpected " "ways." msgstr "" "Le motif d'argument positionnel correspond à celui de :func:`range`. " "N'utilisez pas d'arguments nommés parce que la fonction peut les utiliser de " "manière inattendue." #: library/random.rst:133 msgid "" ":meth:`randrange` is more sophisticated about producing equally distributed " "values. Formerly it used a style like ``int(random()*n)`` which could " "produce slightly uneven distributions." msgstr "" ":meth:`randrange` est plus sophistiquée dans la production de valeurs " "uniformément distribuées. Auparavant, elle utilisait un style comme " "``int(random()*n)`` qui pouvait produire des distributions légèrement " "inégales." #: library/random.rst:138 msgid "" "The automatic conversion of non-integer types to equivalent integers is " "deprecated. Currently ``randrange(10.0)`` is losslessly converted to " "``randrange(10)``. In the future, this will raise a :exc:`TypeError`." msgstr "" "La conversion automatique des types non-entiers est obsolète. Actuellement, " "``randrange(10.0)`` est convertie sans perte en ``randrange(10)``. À " "l’avenir, une exception :exc:`TypeError` sera levée." #: library/random.rst:143 msgid "" "The exception raised for non-integral values such as ``randrange(10.5)`` or " "``randrange('10')`` will be changed from :exc:`ValueError` to :exc:" "`TypeError`." msgstr "" "L’exception levée pour les valeurs non-entières telles que " "``randrange(10.5)`` ou ``randrange(’10’)`` changeront de :exc:`ValueError` " "à :exc:`TypeError`." #: library/random.rst:150 msgid "" "Return a random integer *N* such that ``a <= N <= b``. Alias for " "``randrange(a, b+1)``." msgstr "" "Renvoie un entier aléatoire *N* tel que ``a <= N <= b``. Alias pour " "``randrange(a, b+1)``." #: library/random.rst:155 msgid "" "Returns a non-negative Python integer with *k* random bits. This method is " "supplied with the MersenneTwister generator and some other generators may " "also provide it as an optional part of the API. When available, :meth:" "`getrandbits` enables :meth:`randrange` to handle arbitrarily large ranges." msgstr "" "Renvoie un entier Python non négatif avec *k* bits aléatoires. Cette méthode " "est fournie avec le générateur MersenneTwister. Quelques autres générateurs " "peuvent également la fournir en option comme partie de l'API. Lorsqu'elle " "est disponible, :meth:`getrandbits` permet à :meth:`randrange` de gérer des " "gammes arbitrairement larges." #: library/random.rst:161 msgid "This method now accepts zero for *k*." msgstr "Cette méthode accepte désormais zéro pour *k*." #: library/random.rst:166 msgid "Functions for sequences" msgstr "Fonctions pour les séquences" #: library/random.rst:170 msgid "" "Return a random element from the non-empty sequence *seq*. If *seq* is " "empty, raises :exc:`IndexError`." msgstr "" "Renvoie un élément aléatoire de la séquence non vide *seq*. Si *seq* est " "vide, lève :exc:`IndexError`." #: library/random.rst:175 msgid "" "Return a *k* sized list of elements chosen from the *population* with " "replacement. If the *population* is empty, raises :exc:`IndexError`." msgstr "" "Renvoie une liste de taille *k* d'éléments choisis dans la *population* avec " "remise. Si la *population* est vide, lève :exc:`IndexError`." #: library/random.rst:178 msgid "" "If a *weights* sequence is specified, selections are made according to the " "relative weights. Alternatively, if a *cum_weights* sequence is given, the " "selections are made according to the cumulative weights (perhaps computed " "using :func:`itertools.accumulate`). For example, the relative weights " "``[10, 5, 30, 5]`` are equivalent to the cumulative weights ``[10, 15, 45, " "50]``. Internally, the relative weights are converted to cumulative weights " "before making selections, so supplying the cumulative weights saves work." msgstr "" "Si une séquence de *poids* est spécifiée, les tirages sont effectués en " "fonction des poids relatifs. Alternativement, si une séquence *cum_weights* " "est donnée, les tirages sont faits en fonction des poids cumulés (peut-être " "calculés en utilisant :func:`itertools.accumulate`). Par exemple, les poids " "relatifs ``[10, 5, 30, 5]`` sont équivalents aux poids cumulatifs ``[10, 15, " "45, 50]``. En interne, les poids relatifs sont convertis en poids " "cumulatifs avant d'effectuer les tirages, ce qui vous permet d'économiser du " "travail en fournissant des pondérations cumulatives." #: library/random.rst:187 msgid "" "If neither *weights* nor *cum_weights* are specified, selections are made " "with equal probability. If a weights sequence is supplied, it must be the " "same length as the *population* sequence. It is a :exc:`TypeError` to " "specify both *weights* and *cum_weights*." msgstr "" "Si ni *weights* ni *cum_weights* ne sont spécifiés, les tirages sont " "effectués avec une probabilité uniforme. Si une séquence de poids est " "fournie, elle doit être de la même longueur que la séquence *population*. " "Spécifier à la fois *weights* et *cum_weights* lève une :exc:`TypeError`." #: library/random.rst:192 msgid "" "The *weights* or *cum_weights* can use any numeric type that interoperates " "with the :class:`float` values returned by :func:`random` (that includes " "integers, floats, and fractions but excludes decimals). Weights are assumed " "to be non-negative and finite. A :exc:`ValueError` is raised if all weights " "are zero." msgstr "" "Les *weights* ou *cum_weights* peuvent utiliser n'importe quel type " "numérique interopérable avec les valeurs :class:`float` renvoyées par :func:" "`random` (qui inclut les entiers, les flottants et les fractions mais exclut " "les décimaux). Les poids sont présumés être non négatifs et finis. Une " "exception :exc:`ValueError` est levée si tous les poids sont à zéro." #: library/random.rst:198 msgid "" "For a given seed, the :func:`choices` function with equal weighting " "typically produces a different sequence than repeated calls to :func:" "`choice`. The algorithm used by :func:`choices` uses floating point " "arithmetic for internal consistency and speed. The algorithm used by :func:" "`choice` defaults to integer arithmetic with repeated selections to avoid " "small biases from round-off error." msgstr "" "Pour une graine donnée, la fonction :func:`choices` avec pondération " "uniforme produit généralement une séquence différente des appels répétés à :" "func:`choice`. L'algorithme utilisé par :func:`choices` utilise " "l'arithmétique à virgule flottante pour la cohérence interne et la vitesse. " "L'algorithme utilisé par :func:`choice` utilise par défaut l'arithmétique " "entière avec des tirages répétés pour éviter les petits biais dus aux " "erreurs d'arrondi." #: library/random.rst:207 msgid "Raises a :exc:`ValueError` if all weights are zero." msgstr "Lève une :exc:`ValueError` si tous les poids sont à zéro." #: library/random.rst:213 msgid "Shuffle the sequence *x* in place." msgstr "" "Mélange la séquence *x* sans créer de nouvelle instance (« sur place »)." #: library/random.rst:215 msgid "" "To shuffle an immutable sequence and return a new shuffled list, use " "``sample(x, k=len(x))`` instead." msgstr "" "Pour mélanger une séquence immuable et renvoyer une nouvelle liste mélangée, " "utilisez ``sample(x, k=len(x))`` à la place." #: library/random.rst:218 msgid "" "Note that even for small ``len(x)``, the total number of permutations of *x* " "can quickly grow larger than the period of most random number generators. " "This implies that most permutations of a long sequence can never be " "generated. For example, a sequence of length 2080 is the largest that can " "fit within the period of the Mersenne Twister random number generator." msgstr "" "Notez que même pour les petits ``len(x)``, le nombre total de permutations " "de *x* peut rapidement devenir plus grand que la période de la plupart des " "générateurs de nombres aléatoires. Cela implique que la plupart des " "permutations d'une longue séquence ne peuvent jamais être générées. Par " "exemple, une séquence de longueur 2080 est la plus grande qui puisse tenir " "dans la période du générateur de nombres aléatoires Mersenne Twister." #: library/random.rst:225 msgid "The optional parameter *random*." msgstr "Le paramètre optionnel *random*." #: library/random.rst:230 #, fuzzy msgid "" "Return a *k* length list of unique elements chosen from the population " "sequence. Used for random sampling without replacement." msgstr "" "Renvoie une liste de *k* éléments uniques choisis dans la séquence ou " "l'ensemble de la population. Utilisé pour un tirage aléatoire sans remise." #: library/random.rst:233 msgid "" "Returns a new list containing elements from the population while leaving the " "original population unchanged. The resulting list is in selection order so " "that all sub-slices will also be valid random samples. This allows raffle " "winners (the sample) to be partitioned into grand prize and second place " "winners (the subslices)." msgstr "" "Renvoie une nouvelle liste contenant des éléments de la population tout en " "laissant la population originale inchangée. La liste résultante est classée " "par ordre de sélection de sorte que toutes les sous-tranches soient " "également des échantillons aléatoires valides. Cela permet aux gagnants du " "tirage (l'échantillon) d'être divisés en gagnants du grand prix et en " "gagnants de la deuxième place (les sous-tranches)." #: library/random.rst:239 msgid "" "Members of the population need not be :term:`hashable` or unique. If the " "population contains repeats, then each occurrence is a possible selection in " "the sample." msgstr "" "Les membres de la population n'ont pas besoin d'être :term:" "`hachables` ou uniques. Si la population contient des répétitions, " "alors chaque occurrence est un tirage possible dans l'échantillon." #: library/random.rst:242 msgid "" "Repeated elements can be specified one at a time or with the optional " "keyword-only *counts* parameter. For example, ``sample(['red', 'blue'], " "counts=[4, 2], k=5)`` is equivalent to ``sample(['red', 'red', 'red', 'red', " "'blue', 'blue'], k=5)``." msgstr "" "Les éléments répétés peuvent être spécifiés un à la fois ou avec le " "paramètre optionnel uniquement nommé *counts*. Par exemple, " "``sample([‘red’, ‘blue’], counts=[4, 2], k=5)`` est équivalent à " "``sample([‘red’, ‘red’, ‘red’, ‘red’, ‘blue’, ‘blue’], k=5)``." #: library/random.rst:247 msgid "" "To choose a sample from a range of integers, use a :func:`range` object as " "an argument. This is especially fast and space efficient for sampling from " "a large population: ``sample(range(10000000), k=60)``." msgstr "" "Pour choisir un échantillon parmi un intervalle d'entiers, utilisez un " "objet :func:`range` comme argument. Ceci est particulièrement rapide et " "économe en mémoire pour un tirage dans une grande population : " "``échantillon(range(10000000), k=60)``." #: library/random.rst:251 msgid "" "If the sample size is larger than the population size, a :exc:`ValueError` " "is raised." msgstr "" "Si la taille de l'échantillon est supérieure à la taille de la population, " "une :exc:`ValueError` est levée." #: library/random.rst:254 msgid "Added the *counts* parameter." msgstr "Ajoute le paramètre *counts*." #: library/random.rst:259 msgid "" "The *population* must be a sequence. Automatic conversion of sets to lists " "is no longer supported." msgstr "" #: library/random.rst:266 msgid "Real-valued distributions" msgstr "Distributions pour les nombres réels" #: library/random.rst:268 msgid "" "The following functions generate specific real-valued distributions. " "Function parameters are named after the corresponding variables in the " "distribution's equation, as used in common mathematical practice; most of " "these equations can be found in any statistics text." msgstr "" "Les fonctions suivantes génèrent des distributions spécifiques en nombre " "réels. Les paramètres de fonction sont nommés d'après les variables " "correspondantes de l'équation de la distribution, telles qu'elles sont " "utilisées dans la pratique mathématique courante ; la plupart de ces " "équations peuvent être trouvées dans tout document traitant de statistiques." #: library/random.rst:276 #, fuzzy msgid "" "Return the next random floating point number in the range ``0.0 <= X < 1.0``" msgstr "" "Renvoie le nombre aléatoire à virgule flottante suivant dans la plage [0.0, " "1.0)." #: library/random.rst:281 msgid "" "Return a random floating point number *N* such that ``a <= N <= b`` for ``a " "<= b`` and ``b <= N <= a`` for ``b < a``." msgstr "" "Renvoie un nombre aléatoire à virgule flottante *N* tel que ``a <= N <= b`` " "pour ``a <= b`` et ``b <= N <= a`` pour ``b < a``." #: library/random.rst:284 msgid "" "The end-point value ``b`` may or may not be included in the range depending " "on floating-point rounding in the equation ``a + (b-a) * random()``." msgstr "" "La valeur finale ``b`` peut ou non être incluse dans la plage selon " "l'arrondi à virgule flottante dans l'équation ``a + (b-a) * random()``." #: library/random.rst:290 msgid "" "Return a random floating point number *N* such that ``low <= N <= high`` and " "with the specified *mode* between those bounds. The *low* and *high* bounds " "default to zero and one. The *mode* argument defaults to the midpoint " "between the bounds, giving a symmetric distribution." msgstr "" "Renvoie un nombre aléatoire en virgule flottante *N* tel que ``low <= N <= " "high`` et avec le *mode* spécifié entre ces bornes. Les limites *low* et " "*high* par défaut sont zéro et un. L'argument *mode* est par défaut le " "point médian entre les bornes, ce qui donne une distribution symétrique." #: library/random.rst:298 msgid "" "Beta distribution. Conditions on the parameters are ``alpha > 0`` and " "``beta > 0``. Returned values range between 0 and 1." msgstr "" "Distribution bêta. Les conditions sur les paramètres sont ``alpha > 0`` et " "``beta > 0``. Les valeurs renvoyées varient entre 0 et 1." #: library/random.rst:304 msgid "" "Exponential distribution. *lambd* is 1.0 divided by the desired mean. It " "should be nonzero. (The parameter would be called \"lambda\", but that is a " "reserved word in Python.) Returned values range from 0 to positive infinity " "if *lambd* is positive, and from negative infinity to 0 if *lambd* is " "negative." msgstr "" "Distribution exponentielle. *lambd* est 1,0 divisé par la moyenne désirée. " "Ce ne doit pas être zéro. (Le paramètre aurait dû s'appeler \"lambda\", " "mais c'est un mot réservé en Python.) Les valeurs renvoyées vont de 0 à " "plus l'infini positif si *lambd* est positif, et de moins l'infini à 0 si " "*lambd* est négatif." #: library/random.rst:313 msgid "" "Gamma distribution. (*Not* the gamma function!) Conditions on the " "parameters are ``alpha > 0`` and ``beta > 0``." msgstr "" "Distribution gamma. (*Ce n'est pas* la fonction gamma !) Les conditions sur " "les paramètres sont ``alpha > 0`` et ``beta > 0``." #: library/random.rst:316 msgid "The probability distribution function is::" msgstr "La fonction de distribution de probabilité est ::" #: library/random.rst:325 msgid "" "Normal distribution, also called the Gaussian distribution. *mu* is the " "mean, and *sigma* is the standard deviation. This is slightly faster than " "the :func:`normalvariate` function defined below." msgstr "" "Distributions normales, aussi appelées distribution gaussiennes. *mu* est " "la moyenne et *sigma* est l’écart type. C'est légèrement plus rapide que la " "fonction :func:`normalvariate` définie ci-dessous." #: library/random.rst:329 msgid "" "Multithreading note: When two threads call this function simultaneously, it " "is possible that they will receive the same return value. This can be " "avoided in three ways. 1) Have each thread use a different instance of the " "random number generator. 2) Put locks around all calls. 3) Use the slower, " "but thread-safe :func:`normalvariate` function instead." msgstr "" "Note sur les fils d’exécution multiples (*Multithreading*) : quand deux " "fils d’exécution appellent cette fonction simultanément, il est possible " "qu’ils reçoivent la même valeur de retour. On peut l’éviter de 3 façons. 1) " "Avoir chaque fil utilisant une instance différente du générateur de nombres " "aléatoires. 2) Mettre des verrous autour de tous les appels. 3) Utiliser la " "fonction plus lente, mais compatible avec les programmes à fils d’exécution " "multiples, :func:`normalvariate` à la place." #: library/random.rst:352 msgid "*mu* and *sigma* now have default arguments." msgstr "" #: library/random.rst:342 msgid "" "Log normal distribution. If you take the natural logarithm of this " "distribution, you'll get a normal distribution with mean *mu* and standard " "deviation *sigma*. *mu* can have any value, and *sigma* must be greater " "than zero." msgstr "" "Logarithme de la distribution normale. Si vous prenez le logarithme naturel " "de cette distribution, vous obtiendrez une distribution normale avec *mu* " "moyen et écart-type *sigma*. *mu* peut avoir n'importe quelle valeur et " "*sigma* doit être supérieur à zéro." #: library/random.rst:350 msgid "" "Normal distribution. *mu* is the mean, and *sigma* is the standard " "deviation." msgstr "" "Distribution normale. *mu* est la moyenne et *sigma* est l'écart type." #: library/random.rst:358 msgid "" "*mu* is the mean angle, expressed in radians between 0 and 2\\*\\ *pi*, and " "*kappa* is the concentration parameter, which must be greater than or equal " "to zero. If *kappa* is equal to zero, this distribution reduces to a " "uniform random angle over the range 0 to 2\\*\\ *pi*." msgstr "" "*mu* est l'angle moyen, exprimé en radians entre 0 et 2\\*\\ *pi*, et " "*kappa* est le paramètre de concentration, qui doit être supérieur ou égal à " "zéro. Si *kappa* est égal à zéro, cette distribution se réduit à un angle " "aléatoire uniforme sur la plage de 0 à 2\\*\\ *pi*." #: library/random.rst:366 msgid "Pareto distribution. *alpha* is the shape parameter." msgstr "Distribution de Pareto. *alpha* est le paramètre de forme." #: library/random.rst:371 msgid "" "Weibull distribution. *alpha* is the scale parameter and *beta* is the " "shape parameter." msgstr "" "Distribution de Weibull. *alpha* est le paramètre de l'échelle et *beta* " "est le paramètre de forme." #: library/random.rst:376 msgid "Alternative Generator" msgstr "Générateur alternatif" #: library/random.rst:380 msgid "" "Class that implements the default pseudo-random number generator used by " "the :mod:`random` module." msgstr "" "Classe qui implémente le générateur de nombres pseudo-aléatoires par défaut " "utilisé par le module :mod:`random`." #: library/random.rst:383 msgid "" "In the future, the *seed* must be one of the following types: :class:" "`NoneType`, :class:`int`, :class:`float`, :class:`str`, :class:`bytes`, or :" "class:`bytearray`." msgstr "" "À l’avenir, la *graine* devra être de l’un des types suivants : :class:" "`NoneType`, :class:`int`, :class:`float`, :class:`str`, :class:`bytes` ou :" "class:`bytearray`." #: library/random.rst:390 msgid "" "Class that uses the :func:`os.urandom` function for generating random " "numbers from sources provided by the operating system. Not available on all " "systems. Does not rely on software state, and sequences are not " "reproducible. Accordingly, the :meth:`seed` method has no effect and is " "ignored. The :meth:`getstate` and :meth:`setstate` methods raise :exc:" "`NotImplementedError` if called." msgstr "" "Classe qui utilise la fonction :func:`os.urandom` pour générer des nombres " "aléatoires à partir de sources fournies par le système d'exploitation. Non " "disponible sur tous les systèmes. Ne repose pas sur un état purement " "logiciel et les séquences ne sont pas reproductibles. Par conséquent, la " "méthode :meth:`seed` n'a aucun effet et est ignorée. Les méthodes :meth:" "`getstate` et :meth:`setstate` lèvent :exc:`NotImplementedError` si vous les " "appelez." #: library/random.rst:399 msgid "Notes on Reproducibility" msgstr "Remarques sur la reproductibilité" #: library/random.rst:401 msgid "" "Sometimes it is useful to be able to reproduce the sequences given by a " "pseudo-random number generator. By re-using a seed value, the same sequence " "should be reproducible from run to run as long as multiple threads are not " "running." msgstr "" "Il est parfois utile de pouvoir reproduire les séquences données par un " "générateur de nombres pseudo-aléatoires. En réutilisant la même graine, la " "même séquence devrait être reproductible d'une exécution à l'autre tant que " "plusieurs fils d’exécution ne sont pas en cours." #: library/random.rst:405 msgid "" "Most of the random module's algorithms and seeding functions are subject to " "change across Python versions, but two aspects are guaranteed not to change:" msgstr "" "La plupart des algorithmes et des fonctions de génération de graine du " "module aléatoire sont susceptibles d'être modifiés d'une version à l'autre " "de Python, mais deux aspects sont garantis de ne pas changer ::" #: library/random.rst:408 msgid "" "If a new seeding method is added, then a backward compatible seeder will be " "offered." msgstr "" "Si une nouvelle méthode de génération de graine est ajoutée, une fonction " "rétro-compatible sera offerte." #: library/random.rst:411 msgid "" "The generator's :meth:`~Random.random` method will continue to produce the " "same sequence when the compatible seeder is given the same seed." msgstr "" "La méthode :meth:`~Random.random` du générateur continuera à produire la " "même séquence lorsque la fonction de génération de graine compatible recevra " "la même semence." #: library/random.rst:417 msgid "Examples" msgstr "Exemples" #: library/random.rst:419 msgid "Basic examples::" msgstr "Exemples de base ::" #: library/random.rst:447 msgid "Simulations::" msgstr "Simulations ::" #: library/random.rst:475 msgid "" "Example of `statistical bootstrapping `_ using resampling with replacement to estimate " "a confidence interval for the mean of a sample::" msgstr "" "Exemple de `*bootstrapping* statistique `_ utilisant le ré-échantillonnage avec remise pour " "estimer un intervalle de confiance pour la moyenne d'un échantillon ::" #: library/random.rst:488 msgid "" "Example of a `resampling permutation test `_ to determine the statistical " "significance or `p-value `_ of an " "observed difference between the effects of a drug versus a placebo::" msgstr "" "Exemple d'un `*resampling permutation test* `_ pour déterminer la " "signification statistique ou `valeur p `_ d'une différence observée entre les effets d'un médicament et " "ceux d'un placebo ::" #: library/random.rst:515 msgid "" "Simulation of arrival times and service deliveries for a multiserver queue::" msgstr "" "Simulation des heures d'arrivée et des livraisons de services pour une file " "d'attente de serveurs ::" #: library/random.rst:544 msgid "" "`Statistics for Hackers `_ a " "video tutorial by `Jake Vanderplas `_ on statistical analysis using just a few fundamental " "concepts including simulation, sampling, shuffling, and cross-validation." msgstr "" "`Statistics for Hackers `_ un " "tutoriel vidéo par `Jake Vanderplas `_ sur l'analyse statistique en utilisant seulement quelques " "concepts fondamentaux dont la simulation, l'échantillonnage, le brassage et " "la validation croisée." #: library/random.rst:550 #, fuzzy msgid "" "`Economics Simulation `_ a simulation of a marketplace by `Peter Norvig `_ that shows effective use of many of the tools and " "distributions provided by this module (gauss, uniform, sample, betavariate, " "choice, triangular, and randrange)." msgstr "" "`Economics Simulation `_ simulation d'un marché par `Peter Norvig `_ qui montre l'utilisation efficace de plusieurs des outils et " "distributions fournis par ce module (*gauss*, *uniform*, *sample*, " "*betavariate*, *choice*, *triangular*, et *randrange*)." #: library/random.rst:557 #, fuzzy msgid "" "`A Concrete Introduction to Probability (using Python) `_ a tutorial by `Peter " "Norvig `_ covering the basics of probability " "theory, how to write simulations, and how to perform data analysis using " "Python." msgstr "" "`A Concrete Introduction to Probability (using Python) `_ un tutoriel par " "`Peter Norvig `_ couvrant les bases de la " "théorie des probabilités, comment écrire des simulations, et comment " "effectuer des analyses de données avec Python." #: library/random.rst:565 msgid "Recipes" msgstr "Cas pratiques" #: library/random.rst:567 msgid "" "These recipes show how to efficiently make random selections from the " "combinatoric iterators in the :mod:`itertools` module:" msgstr "" #: library/random.rst:598 msgid "" "The default :func:`.random` returns multiples of 2⁻⁵³ in the range *0.0 ≤ x " "< 1.0*. All such numbers are evenly spaced and are exactly representable as " "Python floats. However, many other representable floats in that interval " "are not possible selections. For example, ``0.05954861408025609`` isn't an " "integer multiple of 2⁻⁵³." msgstr "" "Par défaut :func:`.random` renvoie des multiples de 2⁻⁵³ dans la plage *0.0 " "≤ x < 1.0*. Tous ces nombres sont uniformément répartis et sont représentés " "exactement en tant que nombre à virgule flottante Python. Cependant, de " "nombreux autres nombres à virgule flottante dans cette plage, et " "représentables en Python, ne sont pas sélectionnables. Par exemple " "``0.05954861408025609`` n’est pas un multiple de 2⁻⁵³." #: library/random.rst:604 msgid "" "The following recipe takes a different approach. All floats in the interval " "are possible selections. The mantissa comes from a uniform distribution of " "integers in the range *2⁵² ≤ mantissa < 2⁵³*. The exponent comes from a " "geometric distribution where exponents smaller than *-53* occur half as " "often as the next larger exponent." msgstr "" "La recette suivante utilise une approche différente. Tous les nombres à " "virgule flottante de l’intervalle sont sélectionnables. La mantisse " "provient d’une distribution uniforme d’entiers dans la plage *2⁵² ≤ mantisse " "< 2⁵³*. L’exposant provient d’une distribution géométrique où les exposants " "plus petits que *-53* apparaissent moitié moins souvent que l’exposant " "suivant juste plus grand." #: library/random.rst:626 msgid "" "All :ref:`real valued distributions ` in the " "class will use the new method::" msgstr "" "Toutes les :ref:`real valued distributions ` dans " "la classe seront utilisées dans la nouvelle méthode ::" #: library/random.rst:635 msgid "" "The recipe is conceptually equivalent to an algorithm that chooses from all " "the multiples of 2⁻¹⁰⁷⁴ in the range *0.0 ≤ x < 1.0*. All such numbers are " "evenly spaced, but most have to be rounded down to the nearest representable " "Python float. (The value 2⁻¹⁰⁷⁴ is the smallest positive unnormalized float " "and is equal to ``math.ulp(0.0)``.)" msgstr "" "La recette est conceptuellement équivalente à un algorithme qui choisit " "parmi tous les multiples de 2⁻¹⁰⁷⁴ dans la plage *0.0 ≤ x < 1.0*. Tous ces " "nombres sont uniformément répartis, mais la plupart doivent être arrondis au " "nombre à virgule Python inférieur. (La valeur 2⁻¹⁰⁷⁴ est le plus petit " "nombre à virgule flottante positif et est égal à ``math.ulp(0.0)``.)" #: library/random.rst:644 msgid "" "`Generating Pseudo-random Floating-Point Values `_ a paper by Allen B. Downey describing " "ways to generate more fine-grained floats than normally generated by :func:`." "random`." msgstr "" "`Generating Pseudo-random Floating-Point Values `_ une publication par *Allen B. Downey* " "décrivant des manières de générer des nombres à virgule flottante plus fins " "que normalement générés par :func:`.random`." #~ msgid "" #~ "The optional argument *random* is a 0-argument function returning a " #~ "random float in [0.0, 1.0); by default, this is the function :func:`." #~ "random`." #~ msgstr "" #~ "L'argument optionnel *random* est une fonction sans argument renvoyant un " #~ "nombre aléatoire à virgule flottante dans [0.0, 1.0); par défaut, c'est " #~ "la fonction :func:`.random`." #~ msgid "Examples and Recipes" #~ msgstr "Exemples et recettes"