random number generator

random --- Generate pseudo-random numbers

Original code Lib/random.py

The module implementspseudoto implement random number generators for different distributions.

For integers there is uniform selection of an array. For sequences, there is uniform selection of an randomelement and it is a method to generate a randompermutation of a given list in-place and a method for random sampling that does not require replacement.

On the real line, there's a function to calculate uniform, normal (Gaussian) negatively exponential beta and gamma distributions. For generating distributions of angles such as that of the von Mises Distribution is readily available.

Most modulefunctions All modulefunctions rely on the fundamental routine random() which generates a randomfloat uniformly in the semi-open range [0.0, 1.0). Python uses its Mersenne Twister as the core generator. It produces precision floats of 53 bits and has a timer of 2**19937-1. The base implementation is written in C is fast and thread-safe. The Mersenne Twister is one of the most thoroughly tested random number generators in existence. Since it is deterministic, it is not appropriate for all uses and is completely ineffective for cryptographic applications.

The functions that are provided by this module are actually bound methods for a hidden example of random. Randomclass. It is possible to instantiate your own instances from Random to make generators that do not share state.

Class Random can be subclassed should you want to use a different basic generator designed by you In that case, take over the random(), seed() getstate(), and getstate(), setstate() procedures. Additionally, a new generator may include an getrandbits() method -- this allows rundrange() to produce selections over an arbitrarily large range.

Random module also provides the random module additionally provides its own SystemRandom class, which makes use of its system functions os.urandom() to create random numbers from sources that are provided to the OS.

Warning

The pseudo-random generators in this module should not be used to secure your data. For cryptographic or security-related uses you should refer to the secrets module.

Check out

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 by establishing the random number generator.

If a is missing or otherwise, none The current system time is utilized. If randomness sources can be provided from the operating system are utilized instead of that of the time in system (see for the os.urandom() function for further information on their availability).

If it is an int it is used directly.

In Version 2 (the default) with version 2, a str, bytes, or bytearray object is transformed into the form of an int and all its bits are utilized.

With version 1 (provided for reproducing random sequences that were created in earlier versions of Python) The process of str and bytes results in a more narrow range of seeds.

Modified at Version 3.2:Moved to the version 2 scheme, which utilizes all of the bits in the seed of a string.

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()

An object is returned that reflects the current condition of the generator. This object can be passed to setstate() to restore the state.random.setstate(state)

state should have been obtained via a prior call to the function getstate(), and setstate() restores the internal state of the generator to the state it was at the time the call to getstate() was called.

Functions for bytes

random. randbytes( n)

Generate N random bytes.

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

New in version 3.9.

Functions for integers

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

Return a randomly selected element from range(start, stop, step). This is the same as choice(range(start, stop, step)), but does not create an object of range.

The pattern of argument for position is similar to the pattern of range(). Keyword arguments shouldn't be used because the function may use them in unexpected ways.

Modified with the version 3.2: randrange() is more sophisticated in producing equally distributed values. Before, it employed the style of int(random()*n) which could result in distributions that were slightly uneven.

It is no longer supported as of 3.10 3.10: The automatic conversion of non-integer types into equivalent integers is deprecated. In the moment, randrange(10.0) is unaffectedly converted to randrange(10). In the near future, this will raise an "TypeError".

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 value of N such that the a value is equal to N + the value of. Alias for randrange(a, b+1).random.getrandbits(k)

Returns an non-negative Python integer that contains k random bits. This method is supplied with the MersenneTwister generator and a few other generators may also provide this feature as an optional component within the API. If available, the getrandbits() enables randrange() to handle vast ranges.

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

Sequences and functions

random. selection( seq)

Return a random part of the 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 that are selected to be included in the population with replacement. If the number of elements is not full, it the program raises an the IndexError.

If there is a weights sequence is defined, 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 itertools.accumulate()). For example, the weights relative to [10 5 30, 5, etc.five, 30, 5 can be equated to those of the cumulative weights [10, 15, 45 50[10, 15, 45, 50]. Internally they are transformed to cumulative weights prior making selections thus providing the cumulative weights is a way to save time.

If there is no weights nor cum_weights are provided, the selections are made with equal chance. If a sequence of weights is supplied, it must be similar to the sequence of the population sequence. It's an MethodError to provide that both the weights as well as cum_weights.

Cum_weights and the or cum_weights and cum_weights can be derived from any numerical type that interoperates with the floating values generated by random() (that includes integers, floats, as well as fractions but excludes decimals). Weights are assumed to non-negative and finite. It is a ValueError is raised when any weights have zero.

With a seed that is given, it is the options() function with equal weighting will typically produce a different sequence than numerous calls to choices(). The algorithm used by the choice() uses floating point arithmetic to ensure internal reliability and speed. The algorithm employed by choices() defaults to integer arithmetic , with repeated selections to avoid small errors due to round-off errors.

New in 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 in the sequence to ensure.

The argument is optional. random will be an argument function with zero arguments, returning a random floating pointer in [0.0, 1.0); by default, this functions as random().

To make an immutable sequence shuffled and return a fresh the list shuffled, you can use sample(x, k=len(x)) instead.

It is important to note that even for tiny len(x), the total number permutations of the sequence can be rapidly growing larger than the range of random number generators. That means that the vast majority of permutations of a lengthy sequence will never be produced. For instance, a sequence that's length 2080 is the longest sequence that is possible to fit inside the timeframe 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 K length listing of unique elements that were selected from the sample sequence or set. This is useful for random sampling without replacement.

It returns a new list with elements from the population while leaving the original population unchanged. The resultant list is created organized in order of selection so that all sub-slices are also be valid random samples. This allows winners of raffles (the representative sample) to be partitioned into grand prize winners and second place winner (the subslices).

The individuals in the population should not be hashable or unique. If the population has repeats each time, it is an opportunity to select a member of the sample.

Repeated elements can also be described one at a time or using the keywords-only numbers parameter. For example, sample(['red', blue'], count=[4 2] 5) is equivalent to sample(['red', 'red",'red 'red', 'blue', 'blue'count=[4, 2], k=5).

For selecting a sample of 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 bigger than the total population size, there is a ValueError is raised.

Version 3.9 has been updated. 3.9:Added the counts parameter.

The format is no longer supported as of Version 3.9: In the future, the population will be a sequence. Instances from sets are not supported anymore. The set should first be converted into the form of a array or tuple or tuple, and preferably in a deterministic order so that the set can be replicated.

Real-valued distributions

The following functions generate specific real-valued distributions. Function parameters are named after the variables they correspond to in the equation for the distribution, as they are used in everyday mathematical practice The majority of these equations are available 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 number N that is a <= N <= b in 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 such that low <= Nis high and in the range between those boundaries. The high and high bounds are set to one and zero. The mode argument defaults to the midpoint between the bounds, giving a symmetric distribution.random.betavariate(alpha, beta)

Beta distribution. The parameters must be alpha > 0, or beta > 0. Returned values range between 0 and 1.random.expovariate(lambd)

Exponential distribution. lambd is 1.0 divided by the desired median. It must not be zero. (The parameter could be referred to as "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.random.gammavariate(alpha, beta)

Gamma distribution. ( Not the function gamma!) The conditions for the parameters are beta > 0. or beta > 0..

This probability distribution algorithm:

Notes on Reproducibility

Sometimes it is useful for a reproducible version of the sequences generated by a pseudo-random generator. When reusing a seed value it is possible to make the same sequence be reproducible from run the next, as long as there are no multiple threads are not running.

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

• If a new seeding method is introduced, then an backward-compatible seeder will be made available.
• The generator's random() method will continue to produce the same sequence once a appropriate seeder is given that same seed.