random number generator

random ( random)- Generate pseudo-random numbers

The source code is Lib/random.py

This module implementspseudoIt implements pseudo random number generators for various distributions.

For integers, there is uniform selection of a range. For sequences, there's uniform selection of an randomelement, a function to generate a randompermutation of a list , and a method for random sampling without replacing.

On the actual line, there's a function for computing uniform, normal (Gaussian) positive exponential, lognormal beta and gamma distributions. In order to generate distributions of angles, you can use von Mises range is offered.

Nearly all modulefunctions All modulefunctions rely on the basic modulefunction random() that generates a randomfloat uniformly in the semi-open range [0.0, 1.0). Python makes use of an algorithm called the Mersenne Twister as the core generator. It creates floats with 53 bits of precision with a length of 2**19937-1. The implementation that is underlying in C is both efficient and threadsafe. In fact, the Mersenne Twister is one of the most extensively tested random number generators in existence. However, being completely dependent, it isn't suitable for all scenarios as it is unsuitable to be used for cryptographic purposes.

The functions that are provided by this module are bound methods of a hidden variant of random. Randomclass. It is possible to instantiate your own versions from Random to create generators that aren't sharing state.

Class Random can be subclassed should you need to use a new fundamental generator of your own devising in which case you take over any of the random() (), seed(), getstate(), and settingstate() strategies. In addition, a different generator can supply with a acquirerandbits() method -that permits rundrange() to produce choices over an arbitrarily wide range.

The random module also provides an SystemRandom class that uses functions in the operating system os.urandom() to generate random numbers from the sources supplied to the OS.

Warning

The pseudo-random generators of this module are not recommended for security purposes. For use in cryptography or security look up the secrets module.

See also

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 your random number generator.

If an option is absent or none is specified when None is entered, the current system time is utilized. If randomness sources are made available to the operating system system, then they are substituted for timings set by the operating system (see the os.urandom() function for more information on the availability of these sources).

If it is an int, it can be used directly.

With version 2 (the default) the str, bytes or bytearray object is converted into an int and all its bits are utilized.

With version 1 (provided to reproduce random sequences from older versions of Python), the algorithm for str and bytes yields a smaller number of seeds.

Modified at Version 3.2:Moved to the version 2 scheme that utilizes all of the bits in the string 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()

Create an object that records the current state of the generator. This object can be passed to setstate() to restore the state.random.setstate(state)

state is what you should have gotten via a prior call to findstate(), and setstate() restores the internal state of the generator to what it was when getstate() was called.

Functions for bytes

random. randbytes( n)

Generate N random Bytes.

This method should not be used to generate 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 similar to choice(range(start stop, start, step)), but doesn't actually build an object that is a range.

The pattern of the argument in the positional position matches the pattern of the range(). Keyword arguments should not be used as the function could use them in unexpected ways.

The style was changed with Version 3.2: randrange() is more advanced in producing evenly distributed values. It was previously an approach similar to int(random()*n) which produced slightly different distributions.

Deprecated since Version 3.10: The automatic conversion of non-integer kinds to equivalent integers is not supported. At present, randrange(10.0) is unaffectedly converted to randrange(10). In the near future this could cause a Error in Type.

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 an random numbers N which is such that a <= N B. Alias for randrange(a, b+1).random.getrandbits(k)

Returns a non-negative Python integer with k random bits. This method is included in the MersenneTwister generator and a few other generators might offer this feature as an optional component of the API. If present, getrandbits() enables randrange() to handle massive ranges that are arbitrarily big.

Modified to Version 3.9:This method now accepts zero as the word k.

Sequences can be sequenced using functions.

random. selection( seq)

Return the random element from 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 selected among the population with replacement. If population is not full, it raises IndicateError.

If a weights sequence is specified, choices will be made based on 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-5[10, 5, 30, 5] can be equated to those of the cumulative weights [10, 15, 45, 50and 50. Internally, these weights will be converted to cumulative weights prior making selections and supplying the cumulative weights helps save time.

If there is no weights nor cum_weights are given, then selections are made with equal probabilities. If a sequence of weights is supplied, it must have exactly the same length as the sequence of the population sequence. It is an TypeError to provide the two types of weights: and cum_weights in addition to cum_weights.

There are many ways to calculate weights. or cum_weights and cum_weights are able to use any numerical type that can be used to interoperate with floating results returned in random() (that includes integers, floats, as well as fractions but excludes decimals). Weights are believed to be non-negative and finite. The ValueError is raised if any weights have zero.

With a seed that is given, using the alternatives() function with equal weighting usually results in distinct sequences from multiple calls made to choices(). The algorithm utilized by the choice() uses floating point arithmetic to ensure internal uniformity and speed. The algorithm used to calculate choices() defaults to the integer method of arithmetic and repeats selections in order to avoid slight biases from round-off error.

New Version 3.6.

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

Reshuffle the sequence with x in the same place.

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

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

Be aware that even for tiny len(x), the total number permutations of x can be rapidly growing larger than the period of most random number generators. This implies that most permutations in a long sequence can never be generated. For example, a sequence that is 2080 in length is the longest that fits inside the timeframe in the 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 an number of length list of unique elements chosen from the sequence of population or set. Useful for random sampling without replacement.

The result is a list that contains parts of the population, leaving the original population unaltered. The list that is returned is in selection order so that all sub-slices will remain valid random samples. This allows the raffle winners (the representative sample) to be partitioned into grand prize winners and second prize winner (the subslices).

The members of the population should not be hashable or unique. If the population has repeated instances that means each repetition is a possible selection in the sample.

Repeated elements may be specified individually or by using the optional Keyword-only counting parameter. For example, sample(['red', blue'], count=[4 2] 5, k=5) is equivalent to sample(['red', 'red', 'red' 'red', 'blue", "blue'5).

For selecting a sample of a set of integers, employ the array() object as an argument. This is especially fast and space efficient for sampling from a large population: sample(range(10000000), k=60).

If the sample size is greater than the total population size, an ValueError is raised.

Changed in version 3.9:Added the counts parameter.

No longer supported since version 3.9: In the future it is expected that the population must be a sequence. The instances that are part of a set are not supported anymore. The set must be converted into one of the following: a table or tuple or tuple, and preferably in the same order to ensure that the sample can be reproduced.

Real-valued distributions

The following functions create specific real-valued distributions. Function parameters are named in honor of their respective variables in the equation that generates the distribution. This is utilized in the common mathematical usage Most of these equations 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 number N , such that A = N= b for a= b and b <= Nis a. < 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 which is low= N <means high and that it is in the range between those limits. This is because the low high and low high bounds 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 alpha > 0. and beta > 0.. Returned values range between 0 and 1.random.expovariate(lambd)

Exponential distribution. lambd is 1.0 divided by the desired mean. It should not be zero. (The parameter is referred to as "lambda", but that is a reserved word within 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 parameters must be in the range of alpha > 0 or beta > 0..

The probability distribution function is:

Notes on Reproducibility

Sometimes it's important to be able to replicate the sequences created by a pseudo-random generator. Through re-using the seed value, the same sequence should be reproducible from run the next, as long as there are no multiple threads are not running.

A majority of the random module's algorithms and seeding functions are subject to change across Python versions, but two aspects are guaranteed not to be affected by the changes:

• If a seeding option that is new is added, an backward-compatible seeder will be offered.
• Generator's random() method will produce the same sequence when the compatible observer is given the same seed.