Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 1 | :mod:`random` --- Generate pseudo-random numbers |
| 2 | ================================================ |
| 3 | |
| 4 | .. module:: random |
| 5 | :synopsis: Generate pseudo-random numbers with various common distributions. |
| 6 | |
Raymond Hettinger | 1048094 | 2011-01-10 03:26:08 +0000 | [diff] [blame] | 7 | **Source code:** :source:`Lib/random.py` |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 8 | |
Raymond Hettinger | 4f707fd | 2011-01-10 19:54:11 +0000 | [diff] [blame] | 9 | -------------- |
| 10 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 11 | This module implements pseudo-random number generators for various |
| 12 | distributions. |
| 13 | |
Raymond Hettinger | b21dac1 | 2010-09-07 05:32:49 +0000 | [diff] [blame] | 14 | For integers, there is uniform selection from a range. For sequences, there is |
| 15 | uniform selection of a random element, a function to generate a random |
| 16 | permutation of a list in-place, and a function for random sampling without |
| 17 | replacement. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 18 | |
| 19 | On the real line, there are functions to compute uniform, normal (Gaussian), |
| 20 | lognormal, negative exponential, gamma, and beta distributions. For generating |
| 21 | distributions of angles, the von Mises distribution is available. |
| 22 | |
| 23 | Almost all module functions depend on the basic function :func:`random`, which |
| 24 | generates a random float uniformly in the semi-open range [0.0, 1.0). Python |
| 25 | uses the Mersenne Twister as the core generator. It produces 53-bit precision |
| 26 | floats and has a period of 2\*\*19937-1. The underlying implementation in C is |
| 27 | both fast and threadsafe. The Mersenne Twister is one of the most extensively |
| 28 | tested random number generators in existence. However, being completely |
| 29 | deterministic, it is not suitable for all purposes, and is completely unsuitable |
| 30 | for cryptographic purposes. |
| 31 | |
| 32 | The functions supplied by this module are actually bound methods of a hidden |
| 33 | instance of the :class:`random.Random` class. You can instantiate your own |
Raymond Hettinger | 28de64f | 2008-01-13 23:40:30 +0000 | [diff] [blame] | 34 | instances of :class:`Random` to get generators that don't share state. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 35 | |
| 36 | Class :class:`Random` can also be subclassed if you want to use a different |
| 37 | basic generator of your own devising: in that case, override the :meth:`random`, |
Raymond Hettinger | afd3045 | 2009-02-24 10:57:02 +0000 | [diff] [blame] | 38 | :meth:`seed`, :meth:`getstate`, and :meth:`setstate` methods. |
Benjamin Peterson | d18de0e | 2008-07-31 20:21:46 +0000 | [diff] [blame] | 39 | Optionally, a new generator can supply a :meth:`getrandbits` method --- this |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 40 | allows :meth:`randrange` to produce selections over an arbitrarily large range. |
| 41 | |
Benjamin Peterson | 21896a3 | 2010-03-21 22:03:03 +0000 | [diff] [blame] | 42 | The :mod:`random` module also provides the :class:`SystemRandom` class which |
| 43 | uses the system function :func:`os.urandom` to generate random numbers |
| 44 | from sources provided by the operating system. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 45 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 46 | |
Raymond Hettinger | 1048094 | 2011-01-10 03:26:08 +0000 | [diff] [blame] | 47 | Bookkeeping functions: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 48 | |
Raymond Hettinger | f763a72 | 2010-09-07 00:38:15 +0000 | [diff] [blame] | 49 | .. function:: seed([x], version=2) |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 50 | |
Raymond Hettinger | f763a72 | 2010-09-07 00:38:15 +0000 | [diff] [blame] | 51 | Initialize the random number generator. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 52 | |
Raymond Hettinger | f763a72 | 2010-09-07 00:38:15 +0000 | [diff] [blame] | 53 | If *x* is omitted or ``None``, the current system time is used. If |
| 54 | randomness sources are provided by the operating system, they are used |
| 55 | instead of the system time (see the :func:`os.urandom` function for details |
| 56 | on availability). |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 57 | |
Raymond Hettinger | f763a72 | 2010-09-07 00:38:15 +0000 | [diff] [blame] | 58 | If *x* is an int, it is used directly. |
| 59 | |
| 60 | With version 2 (the default), a :class:`str`, :class:`bytes`, or :class:`bytearray` |
Raymond Hettinger | 3149f9c | 2010-09-07 05:35:10 +0000 | [diff] [blame] | 61 | object gets converted to an :class:`int` and all of its bits are used. With version 1, |
Raymond Hettinger | f763a72 | 2010-09-07 00:38:15 +0000 | [diff] [blame] | 62 | the :func:`hash` of *x* is used instead. |
| 63 | |
| 64 | .. versionchanged:: 3.2 |
| 65 | Moved to the version 2 scheme which uses all of the bits in a string seed. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 66 | |
| 67 | .. function:: getstate() |
| 68 | |
| 69 | Return an object capturing the current internal state of the generator. This |
| 70 | object can be passed to :func:`setstate` to restore the state. |
| 71 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 72 | |
| 73 | .. function:: setstate(state) |
| 74 | |
| 75 | *state* should have been obtained from a previous call to :func:`getstate`, and |
| 76 | :func:`setstate` restores the internal state of the generator to what it was at |
Sandro Tosi | 985104a | 2012-08-12 15:12:15 +0200 | [diff] [blame^] | 77 | the time :func:`getstate` was called. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 78 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 79 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 80 | .. function:: getrandbits(k) |
| 81 | |
Ezio Melotti | 0639d5a | 2009-12-19 23:26:38 +0000 | [diff] [blame] | 82 | Returns a Python integer with *k* random bits. This method is supplied with |
Georg Brandl | 5c10664 | 2007-11-29 17:41:05 +0000 | [diff] [blame] | 83 | the MersenneTwister generator and some other generators may also provide it |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 84 | as an optional part of the API. When available, :meth:`getrandbits` enables |
| 85 | :meth:`randrange` to handle arbitrarily large ranges. |
| 86 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 87 | |
| 88 | Functions for integers: |
| 89 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 90 | .. function:: randrange([start,] stop[, step]) |
| 91 | |
| 92 | Return a randomly selected element from ``range(start, stop, step)``. This is |
| 93 | equivalent to ``choice(range(start, stop, step))``, but doesn't actually build a |
| 94 | range object. |
| 95 | |
Raymond Hettinger | 0515661 | 2010-09-07 04:44:52 +0000 | [diff] [blame] | 96 | The positional argument pattern matches that of :func:`range`. Keyword arguments |
| 97 | should not be used because the function may use them in unexpected ways. |
| 98 | |
| 99 | .. versionchanged:: 3.2 |
| 100 | :meth:`randrange` is more sophisticated about producing equally distributed |
| 101 | values. Formerly it used a style like ``int(random()*n)`` which could produce |
| 102 | slightly uneven distributions. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 103 | |
| 104 | .. function:: randint(a, b) |
| 105 | |
Raymond Hettinger | afd3045 | 2009-02-24 10:57:02 +0000 | [diff] [blame] | 106 | Return a random integer *N* such that ``a <= N <= b``. Alias for |
| 107 | ``randrange(a, b+1)``. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 108 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 109 | |
Georg Brandl | 55ac8f0 | 2007-09-01 13:51:09 +0000 | [diff] [blame] | 110 | Functions for sequences: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 111 | |
| 112 | .. function:: choice(seq) |
| 113 | |
| 114 | Return a random element from the non-empty sequence *seq*. If *seq* is empty, |
| 115 | raises :exc:`IndexError`. |
| 116 | |
| 117 | |
| 118 | .. function:: shuffle(x[, random]) |
| 119 | |
| 120 | Shuffle the sequence *x* in place. The optional argument *random* is a |
| 121 | 0-argument function returning a random float in [0.0, 1.0); by default, this is |
| 122 | the function :func:`random`. |
| 123 | |
| 124 | Note that for even rather small ``len(x)``, the total number of permutations of |
| 125 | *x* is larger than the period of most random number generators; this implies |
| 126 | that most permutations of a long sequence can never be generated. |
| 127 | |
| 128 | |
| 129 | .. function:: sample(population, k) |
| 130 | |
Raymond Hettinger | 1acde19 | 2008-01-14 01:00:53 +0000 | [diff] [blame] | 131 | Return a *k* length list of unique elements chosen from the population sequence |
| 132 | or set. Used for random sampling without replacement. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 133 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 134 | Returns a new list containing elements from the population while leaving the |
| 135 | original population unchanged. The resulting list is in selection order so that |
| 136 | all sub-slices will also be valid random samples. This allows raffle winners |
| 137 | (the sample) to be partitioned into grand prize and second place winners (the |
| 138 | subslices). |
| 139 | |
Guido van Rossum | 2cc30da | 2007-11-02 23:46:40 +0000 | [diff] [blame] | 140 | Members of the population need not be :term:`hashable` or unique. If the population |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 141 | contains repeats, then each occurrence is a possible selection in the sample. |
| 142 | |
| 143 | To choose a sample from a range of integers, use an :func:`range` object as an |
| 144 | argument. This is especially fast and space efficient for sampling from a large |
| 145 | population: ``sample(range(10000000), 60)``. |
| 146 | |
| 147 | The following functions generate specific real-valued distributions. Function |
| 148 | parameters are named after the corresponding variables in the distribution's |
| 149 | equation, as used in common mathematical practice; most of these equations can |
| 150 | be found in any statistics text. |
| 151 | |
| 152 | |
| 153 | .. function:: random() |
| 154 | |
| 155 | Return the next random floating point number in the range [0.0, 1.0). |
| 156 | |
| 157 | |
| 158 | .. function:: uniform(a, b) |
| 159 | |
Benjamin Peterson | b58dda7 | 2009-01-18 22:27:04 +0000 | [diff] [blame] | 160 | Return a random floating point number *N* such that ``a <= N <= b`` for |
| 161 | ``a <= b`` and ``b <= N <= a`` for ``b < a``. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 162 | |
Raymond Hettinger | be40db0 | 2009-06-11 23:12:14 +0000 | [diff] [blame] | 163 | The end-point value ``b`` may or may not be included in the range |
| 164 | depending on floating-point rounding in the equation ``a + (b-a) * random()``. |
Benjamin Peterson | 35e8c46 | 2008-04-24 02:34:53 +0000 | [diff] [blame] | 165 | |
Georg Brandl | 73dd7c7 | 2011-09-17 20:36:28 +0200 | [diff] [blame] | 166 | |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 167 | .. function:: triangular(low, high, mode) |
| 168 | |
Benjamin Peterson | b58dda7 | 2009-01-18 22:27:04 +0000 | [diff] [blame] | 169 | Return a random floating point number *N* such that ``low <= N <= high`` and |
Christian Heimes | cc47b05 | 2008-03-25 14:56:36 +0000 | [diff] [blame] | 170 | with the specified *mode* between those bounds. The *low* and *high* bounds |
| 171 | default to zero and one. The *mode* argument defaults to the midpoint |
| 172 | between the bounds, giving a symmetric distribution. |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 173 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 174 | |
| 175 | .. function:: betavariate(alpha, beta) |
| 176 | |
Benjamin Peterson | b58dda7 | 2009-01-18 22:27:04 +0000 | [diff] [blame] | 177 | Beta distribution. Conditions on the parameters are ``alpha > 0`` and |
| 178 | ``beta > 0``. Returned values range between 0 and 1. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 179 | |
| 180 | |
| 181 | .. function:: expovariate(lambd) |
| 182 | |
Mark Dickinson | 2f94736 | 2009-01-07 17:54:07 +0000 | [diff] [blame] | 183 | Exponential distribution. *lambd* is 1.0 divided by the desired |
| 184 | mean. It should be nonzero. (The parameter would be called |
| 185 | "lambda", but that is a reserved word in Python.) Returned values |
| 186 | range from 0 to positive infinity if *lambd* is positive, and from |
| 187 | negative infinity to 0 if *lambd* is negative. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 188 | |
| 189 | |
| 190 | .. function:: gammavariate(alpha, beta) |
| 191 | |
Benjamin Peterson | b58dda7 | 2009-01-18 22:27:04 +0000 | [diff] [blame] | 192 | Gamma distribution. (*Not* the gamma function!) Conditions on the |
| 193 | parameters are ``alpha > 0`` and ``beta > 0``. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 194 | |
Georg Brandl | 73dd7c7 | 2011-09-17 20:36:28 +0200 | [diff] [blame] | 195 | The probability distribution function is:: |
| 196 | |
| 197 | x ** (alpha - 1) * math.exp(-x / beta) |
| 198 | pdf(x) = -------------------------------------- |
| 199 | math.gamma(alpha) * beta ** alpha |
| 200 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 201 | |
| 202 | .. function:: gauss(mu, sigma) |
| 203 | |
Benjamin Peterson | b58dda7 | 2009-01-18 22:27:04 +0000 | [diff] [blame] | 204 | Gaussian distribution. *mu* is the mean, and *sigma* is the standard |
| 205 | deviation. This is slightly faster than the :func:`normalvariate` function |
| 206 | defined below. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 207 | |
| 208 | |
| 209 | .. function:: lognormvariate(mu, sigma) |
| 210 | |
| 211 | Log normal distribution. If you take the natural logarithm of this |
| 212 | distribution, you'll get a normal distribution with mean *mu* and standard |
| 213 | deviation *sigma*. *mu* can have any value, and *sigma* must be greater than |
| 214 | zero. |
| 215 | |
| 216 | |
| 217 | .. function:: normalvariate(mu, sigma) |
| 218 | |
| 219 | Normal distribution. *mu* is the mean, and *sigma* is the standard deviation. |
| 220 | |
| 221 | |
| 222 | .. function:: vonmisesvariate(mu, kappa) |
| 223 | |
| 224 | *mu* is the mean angle, expressed in radians between 0 and 2\*\ *pi*, and *kappa* |
| 225 | is the concentration parameter, which must be greater than or equal to zero. If |
| 226 | *kappa* is equal to zero, this distribution reduces to a uniform random angle |
| 227 | over the range 0 to 2\*\ *pi*. |
| 228 | |
| 229 | |
| 230 | .. function:: paretovariate(alpha) |
| 231 | |
| 232 | Pareto distribution. *alpha* is the shape parameter. |
| 233 | |
| 234 | |
| 235 | .. function:: weibullvariate(alpha, beta) |
| 236 | |
| 237 | Weibull distribution. *alpha* is the scale parameter and *beta* is the shape |
| 238 | parameter. |
| 239 | |
| 240 | |
Raymond Hettinger | 3cdf871 | 2010-12-02 05:35:35 +0000 | [diff] [blame] | 241 | Alternative Generator: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 242 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 243 | .. class:: SystemRandom([seed]) |
| 244 | |
| 245 | Class that uses the :func:`os.urandom` function for generating random numbers |
| 246 | from sources provided by the operating system. Not available on all systems. |
Raymond Hettinger | 3cdf871 | 2010-12-02 05:35:35 +0000 | [diff] [blame] | 247 | Does not rely on software state, and sequences are not reproducible. Accordingly, |
Raymond Hettinger | afd3045 | 2009-02-24 10:57:02 +0000 | [diff] [blame] | 248 | the :meth:`seed` method has no effect and is ignored. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 249 | The :meth:`getstate` and :meth:`setstate` methods raise |
| 250 | :exc:`NotImplementedError` if called. |
| 251 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 252 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 253 | .. seealso:: |
| 254 | |
| 255 | M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-dimensionally |
| 256 | equidistributed uniform pseudorandom number generator", ACM Transactions on |
| 257 | Modeling and Computer Simulation Vol. 8, No. 1, January pp.3-30 1998. |
| 258 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 259 | |
Raymond Hettinger | 1fd32a6 | 2009-04-01 20:52:13 +0000 | [diff] [blame] | 260 | `Complementary-Multiply-with-Carry recipe |
Raymond Hettinger | 9743fd0 | 2009-04-03 05:47:33 +0000 | [diff] [blame] | 261 | <http://code.activestate.com/recipes/576707/>`_ for a compatible alternative |
| 262 | random number generator with a long period and comparatively simple update |
Raymond Hettinger | 1fd32a6 | 2009-04-01 20:52:13 +0000 | [diff] [blame] | 263 | operations. |
Raymond Hettinger | 435cb0f | 2010-09-06 23:36:31 +0000 | [diff] [blame] | 264 | |
Raymond Hettinger | 3cdf871 | 2010-12-02 05:35:35 +0000 | [diff] [blame] | 265 | |
Raymond Hettinger | 435cb0f | 2010-09-06 23:36:31 +0000 | [diff] [blame] | 266 | Notes on Reproducibility |
Antoine Pitrou | e72b586 | 2010-12-12 20:13:31 +0000 | [diff] [blame] | 267 | ------------------------ |
Raymond Hettinger | 435cb0f | 2010-09-06 23:36:31 +0000 | [diff] [blame] | 268 | |
| 269 | Sometimes it is useful to be able to reproduce the sequences given by a pseudo |
| 270 | random number generator. By re-using a seed value, the same sequence should be |
| 271 | reproducible from run to run as long as multiple threads are not running. |
| 272 | |
| 273 | Most of the random module's algorithms and seeding functions are subject to |
| 274 | change across Python versions, but two aspects are guaranteed not to change: |
| 275 | |
| 276 | * If a new seeding method is added, then a backward compatible seeder will be |
| 277 | offered. |
| 278 | |
| 279 | * The generator's :meth:`random` method will continue to produce the same |
| 280 | sequence when the compatible seeder is given the same seed. |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 281 | |
Raymond Hettinger | 6e35394 | 2010-12-04 23:42:12 +0000 | [diff] [blame] | 282 | .. _random-examples: |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 283 | |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 284 | Examples and Recipes |
Antoine Pitrou | e72b586 | 2010-12-12 20:13:31 +0000 | [diff] [blame] | 285 | -------------------- |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 286 | |
Raymond Hettinger | 3cdf871 | 2010-12-02 05:35:35 +0000 | [diff] [blame] | 287 | Basic usage:: |
| 288 | |
| 289 | >>> random.random() # Random float x, 0.0 <= x < 1.0 |
| 290 | 0.37444887175646646 |
| 291 | |
| 292 | >>> random.uniform(1, 10) # Random float x, 1.0 <= x < 10.0 |
| 293 | 1.1800146073117523 |
| 294 | |
| 295 | >>> random.randrange(10) # Integer from 0 to 9 |
| 296 | 7 |
| 297 | |
| 298 | >>> random.randrange(0, 101, 2) # Even integer from 0 to 100 |
| 299 | 26 |
| 300 | |
| 301 | >>> random.choice('abcdefghij') # Single random element |
| 302 | 'c' |
| 303 | |
| 304 | >>> items = [1, 2, 3, 4, 5, 6, 7] |
| 305 | >>> random.shuffle(items) |
| 306 | >>> items |
| 307 | [7, 3, 2, 5, 6, 4, 1] |
| 308 | |
| 309 | >>> random.sample([1, 2, 3, 4, 5], 3) # Three samples without replacement |
| 310 | [4, 1, 5] |
| 311 | |
Sandro Tosi | 1ee1719 | 2012-04-14 16:01:17 +0200 | [diff] [blame] | 312 | A common task is to make a :func:`random.choice` with weighted probabilities. |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 313 | |
| 314 | If the weights are small integer ratios, a simple technique is to build a sample |
| 315 | population with repeats:: |
| 316 | |
| 317 | >>> weighted_choices = [('Red', 3), ('Blue', 2), ('Yellow', 1), ('Green', 4)] |
| 318 | >>> population = [val for val, cnt in weighted_choices for i in range(cnt)] |
| 319 | >>> random.choice(population) |
| 320 | 'Green' |
| 321 | |
Raymond Hettinger | 3cdf871 | 2010-12-02 05:35:35 +0000 | [diff] [blame] | 322 | A more general approach is to arrange the weights in a cumulative distribution |
| 323 | with :func:`itertools.accumulate`, and then locate the random value with |
| 324 | :func:`bisect.bisect`:: |
Raymond Hettinger | 2fdc7b1 | 2010-12-02 02:41:33 +0000 | [diff] [blame] | 325 | |
| 326 | >>> choices, weights = zip(*weighted_choices) |
| 327 | >>> cumdist = list(itertools.accumulate(weights)) |
| 328 | >>> x = random.random() * cumdist[-1] |
| 329 | >>> choices[bisect.bisect(cumdist, x)] |
| 330 | 'Blue' |