random number generator

random -Generate pseudo-random numbers

The source code is Lib/random.py

The module implementspseudoto implement random number generators for different distributions.

For integers, there is an uniform selection from a range. For sequences, there's uniform selection of the randomelement that is an algorithm to generate a randompermutation of a list at-place and a program for random sampling without replacement.

On the real line, there are tools to calculate uniform, normal (Gaussian), Lognormal, Negative exponential, beta, and gamma. For the purpose of generating distributions for angles such as you can use von Mises range is offered.

A majority of modulefunctions All modulefunctions rely on the fundamental routine random(), which generates a randomfloat consistently across the semi-open interval [0.0, 1.0). Python makes use of the Mersenne Twister as the core generator. It produces floats that are 53-bit precise and has a period of 2**19937-1. The underlying implementation is written in C is both speedy and threadsafe. A. The Mersenne Twister is one of the most extensively studied random number generators in existence. However, being completely unpredictable, it's suitable for all purposes as it is unsuitable for cryptographic purposes.

The functions supplied by this module are actually bound methods of a hidden example of random. Randomclass. You can instantiate your own versions from Random for generators that don't share their state.

Class Random may also be subclassed if require a completely different base generator that you create in which case you override any of the random() or seed() getstate() as well as the setstate() method. Optionally, a new generator can supply the obtainrandbits() method -- this allows randrange() to produce choices over an arbitrarily wide range.

It also includes the random module also provides also the SystemRandom class that uses its system functions os.urandom() to generate random numbers from sources provided by operating systems.

Warning

The pseudo-random generators of this module are not recommended for security reasons. For cryptographic or security-related uses, see the secrets module.

Also, see

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.

Complementary-Multiply-with-Carry recipe for a compatible alternative random number generator with a long period and comparatively simple update operations.

Bookkeeping functions

random.seed(a=None, version=2)

Start the random number generator.

If the option is omitted or otherwise, none If none is specified, the currently running system's clock time used. If randomness sources are available through the OS, these sources are used in place of that of the time in system (see for the os.urandom() function for information about availability).

If you are using a is an int it is used directly.

With Version 2 (the default) the str, bytes as well as a bytearray object will be converted to an int and all its bits are utilized.

In version 1 (provided for reproducing random sequences from earlier versions of Python) The procedure to calculate str and bytes produces a smaller range of seeds.

Modified to Version 3.2:Moved to the version 2 scheme, which utilizes every bit of an unicode seed.

Deprecated since version 3.9: In the future, the seed must be one of the following types: NoneType, int, float, str, bytes, or bytearray.random.getstate()

The returned object will record the current internal state of the generator. This object can be passed to setstate() to restore the state.random.setstate(state)

state must have been obtained from an earlier call to the function getstate(), and setstate() restores the internal state of the generator to the state it was at the time getstate() was called.

Functions for bytes

random. randbytes( n)

Generate an amount of random bytes.

This method shouldn't be used to create security tokens. Use secrets.token_bytes() instead.

New Version 3.9.

Functions for integers

random.randrange(stop)random.randrange(start, stop[, step])

Return an element randomly selected from range(start or stop step). This is equivalent to choice(range(start stop, start, step)), but does not actually create a range object.

The pattern of arguments for positions is similar to the format of range(). Keyword arguments shouldn't be used as the program can use them in a variety of unexpected ways.

Modified to version 3.2: randrange() is more sophisticated about producing equally distributed values. It was previously an approach similar to int(random()*n) which produced slightly different distributions.

Refused since version 3.10: The automatic conversion of non-integer numbers to equivalent integers is not supported. Currently, randrange(10.0) is losslessly converted to randrange(10). In the future this may cause a TypError.

Deprecated since version 3.10: The exception raised for non-integral values such as randrange(10.5) or randrange('10') will be changed from ValueError to TypeError.random.randint(a, b)

Return a random integer N such that the a value is equal to N <= B. Alias for randrange(a, b+1).random.getrandbits(k)

Returns an unnegative Python integer with k random bits. This method is available with the MersenneTwister generator and a few other generators could also provide it as an optional part of the API. When it is available findrandbits() enables randrange() to handle massive ranges that are arbitrarily big.

Modified with version 3.9:This method now accepts zero as the letter k..

Sequences and functions

random. selection( seq)

Return the random item from empty sequence seq. If seq is empty, raises IndexError.random.choices(population, weights=None, *, cum_weights=None, k=1)

Return the K sized list of elements to be included in the population with replacement. If populace is not full, it raises indexError.

If a weights sequence is given, then selections are made based on the weights in relation to the. Alternatively, if a cum_weights sequence is given, the selections are made according to the cumulative weights (perhaps computed using itertools.accumulate()). For instance, the weights relative to [10, 5 30-5five, 30, 5 correspond to cumulative weights [10, 15 45, 50for example]. Internally, they are transformed into cumulative weights before making decisions, so supplying the cumulative weights saves work.

If there is no weights or cum_weights are provided, the selections can be made with equal likelihood. If a sequence of weights is supplied, it must have at least the same length as the number of people in the sequence. It's a MethodError to specify the two types of weights: cum_weights as well as cum_weights.

Weights or cum_weights weighs or cum_weights can be derived from any numerical type that interoperates with the floating results returned to random() (that includes integers, floating points, and fractions, but not decimals). Weights are assumed to non-negative and finite. A ValueError is raised if all weights are zero.

Based on a given seed the selection() function with equal weighting is typically able to produce a different sequence than numerous calls to choice(). The algorithm employed by the choice() uses floating point arithmetic to ensure internal reliability and speed. The algorithm employed for the choice() defaults to integer arithmetic , with repeated selections in order to avoid slight variations due to round off error.

New Version 3.6.

Changed in version 3.9: Raises a ValueError if all weights are zero.random.shuffle(x[, random])

Make sure to move the by x into place.

The argument is optional. random can be an 0-argument function that returns a random floating value in [0.0, 1.0); by default, it functions as random().

To move an immutable list and return a fresh shuffled list, use sample(x, k=len(x)) instead.

Noting that even for a tiny len(x), the total number permutations of x will rapidly increase to be larger than the time span of many random number generators. This implies that the vast majority of permutations of a lengthy sequence are not possible to generate. As an example, a sequence that is 2080 in length is the biggest that could fit within the period that is the duration of Mersenne Twister random number generator.

Deprecated since version 3.9, will be removed in version 3.11: The optional parameter random.random.sample(population, k, *, counts=None)

Return a one-kilo length list of distinct elements selected from the sequence of population or set. This is useful for random sampling, without replacement.

Returns a fresh list of parts of the population, maintaining the original sample. The resulting list is ordered in a selection order, which means that all sub-slices will remain valid random samples. This allows raffle winners (the sample) to be divided into grand prize winners and second place winner (the subslices).

The population members need not be hashable or unique. If the sample contains repeated members every occurrence of a possible selection in the sample.

Repeated elements can also be described in one go or with the optional keyword-only count parameter. For instance, sample(['red', blue'], count=[4, 2], k=5) is equivalent to sample(['red', 'red', 'red' blue','red", "blue'five), k=5.).

To select a sample from a range of integers, use an number() object as an argument. This is especially fast and space efficient for sampling from a large population: sample(range(10000000), k=60).

If the size of the sample is greater than the size of the population, there is a ValueError is raised.

Updated in version 3.9:Added the counts parameter.

It is now deprecated as of the version 3.9: In the future it is expected that the population should be a sequence. Instances in the form of the set are not supported anymore. The set first needs to be converted into an listing or tuple, preferably in the order of determinism so that the sample is reproducible.

Real-valued distributions

The following programs generate real-valued distributions. Function parameters are named in honor of the variables they correspond to in the equation for the distribution, as used in common mathematical practice The majority of these formulas can be found in any text on statistics. random. random()

Return the next random floating point number in the range [0.0, 1.0).random.uniform(a, b)

Return an random floating point N with N = a= b, for a= b, and b= N <means a for < N = a for b.

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().random.triangular(low, high, mode)

Return a random floating point value N in a way that low= N= high and that it is in the modus between these limits. There are two bounds: the high and high limits default to zero and one. The mode argument defaults to the midpoint between the bounds, giving a symmetric distribution.random.betavariate(alpha, beta)

Beta distribution. The conditions for the parameters are beta > and 0 or beta > 0.. Returned values range between 0 and 1.random.expovariate(lambd)

Exponential distribution. lambd is 1.0 divided by the desired mean. It must not be zero. (The parameter is called "lambda", but that is a reserved term in Python.) Returned values range from 0 to positive infinity if lambd is positive, and from negative infinity to 0 if lambd is negative.random.gammavariate(alpha, beta)

Gamma distribution. ( Not the function gamma!) Conditions on the parameters are alpha > zero or beta > zero.

A probability distribution formula:

Notes on Reproducibility

Sometimes, it's helpful for a reproducible version of the sequences produced by a pseudo-random number generator. Re-using a seed's value, the same sequence should be able to be reproduced from run to the next, as long as there are no multiple threads aren't running.

Most of the random module's algorithms and seeding algorithms are subject to change between Python versions, but two things are certain not to change:

• If a new method of seeding is added, then an backward-compatible seeder will be provided.
• A generator's random() method continues to produce the same sequence if a appropriate seeder is given that same seed.