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's a 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 list at-place and a program for random sampling without replacement.

On the real line, there are tools to calculate normal, uniform (Gaussian), negatively exponential, gamma, and beta distributions. For the purpose of generating distributions for angles such as the von Mises distributive is accessible.

Almost all modulefunctions Most module functions rely on the core method random() that generates a randomfloat with a uniform semi-open spectrum [0.0, 1.0). Python makes use of an algorithm called the Mersenne Twister as the core generator. It produces 53-bit precision floats and runs for 2**19937-1. The base implementation is written in C is both efficient and threadsafe. In fact, the Mersenne Twister is one of the most extensively testable random number generators in existence. Since it is deterministic, it is not suitable for all scenarios as it is unsuitable for cryptographic use.

The functions offered by this module are bound methods of a hidden instance of the random. Randomclass. You can build your own versions that use Random to get generators that don't share state.

Class Random could be subclassed in the event that you want to use a different fundamental generator from your own invention and in that instance, override any of the random() seeds(), getstate() and createstate() methods. A new generator could include a obtainrandbits() method -which lets the randrange() to produce random selections that span an infinitely wide range.

This random module additionally includes it with the SystemRandom class, which makes use of its system functions os.urandom() to generate random numbers from data sources provided from the operating system.

Warning

The pseudo-random generators of this module should not be used for security reasons. For use in cryptography or security look up 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)

Initiate your random number generator.

If an option is left out or otherwise, none otherwise, the moment in time of the system is utilized. If randomness sources are offered in the system by operating systems, they will be utilized instead of the system time (see for the os.urandom() function for further information on their availability).

If the value is an integer, it is directly used.

In version 2 (the default) an str, bytes as well as a bytearray object is transformed to the form of an int and all of its bits are utilized.

Version 1 (provided for reproducing random sequences that were created in earlier versions of Python) the method for str and bytes results in a more narrow range of seeds.

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

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

state could have come via a prior call to obtain state(), and setstate() restores the internal state of the generator to what it was when the call to getstate() was called.

Functions for bytes

random. randbytes( n)

Generate an amount of random bytes.

This method should not 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 an element randomly selected from range(start or stop step). This is the same as choice(range(start stop, step)), but does not create a range object.

The pattern of the argument in the positional position matches the argument pattern used in range(). Keyword arguments shouldn't be used since the function might use them in unintended ways.

Modified since version 3.2: randrange() is more advanced in producing equally distributed values. Formerly it used the same style as int(random()*n) which could produce slightly uneven distributions.

Refused since Version 3.10: The automatic conversion of non-integer numbers to equivalent integers is deprecated. Currently randrange(10.0) is losslessly converted to randrange(10). In the near future it will result in 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 an random int N such that an a= N B. Alias for randrange(a, b+1).random.getrandbits(k)

Returns a non-negative Python integer that contains K random bits. This method is available with the MersenneTwister generator and some other generators could also provide it as an optional part of the API. If it is available, the getrandbits() enables randrange() to handle massive ranges that are arbitrarily big.

Updated from Version 3.9:This method now accepts zero for k.

Functions to sequences

random. choice( 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 an K size listing of elements chosen among the population with replacement. If the population is empty, raises an IndexError.

If a weights sequence is defined, 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, 5respectively] can be equated to those of the cumulative weights [10 15 45 50and 50. Internally, the relative weights are converted into cumulative weights before making decisions therefore, providing the cumulative weights will save time.

If there is no weights nor cum_weights are specified, all selections are made with equal chance. If a weights sequence is specified, it must be at least the same length as the number of people in the sequence. It's a kind of error to define that both weighs and cum_weights.

Cum_weights and the weighs also known as cum_weights can be used with any numeric type that is compatible with the float values returned through random() (that includes integers, floats and fractions, but does not include decimals). Weights are presumed to be non-negative and finite. A ValueError is raised if the weights all are null.

Based on a given seed it is the choice() function with equal weighting is typically able to produce an entirely different sequence than the many calls the choice(). The algorithm used by choices() uses floating point arithmetic for internal reliability and speed. The algorithm used by choice() defaults to integer arithmetic , with repeated choices to prevent small distortions caused by round-off error.

New Version 3.6.

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

The sequence is shuffled in the sequence into place.

The argument is optional. random could be the function with 0 arguments that return a random floating in [0.0, 1.0); by default, this is the function random().

To move an immutable list and return a new shuffled list, 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 could quickly increase than the length of time of most random number generators. This means that the majority of the permutations for a long sequence are not possible to generate. For example, a series of length 2080 is the longest that fits within the range 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 K length listing of unique elements that were selected from the set of elements or the population set. It is used for random sampling with no 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 have the same validity as random samples. This allows winners of raffles (the sample) to be partitioned into grand prize winners and second prize winners (the subslices).

The members of the population should not be unique or hashable. If the population has repeats every occurrence of one of the possible selections in the sample.

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

For selecting a sample of an array of integers use a the range() 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 larger than the total population size, the ValueError is raised.

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

It is now deprecated as of version 3.9: In the future, the population has to be a sequential. Instances from sets are no longer supported. The set first needs to be converted into one of the following: a or tuple. or tuple at least in the same order to ensure that the sample is reproducible.

Real-valued distributions

The following functions generate specific real-valued distributions. The parameters of the function are named after those variables within the equation for the distribution as commonly used in mathematical practices 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 a random floating point number N , such that the inverse of N= b for a <= b, and b= N <is a. the value of.

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 an random floating point value N which is low <= Nequals high and in the the mode between these bounds. It is assumed that the lower and high limits default 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. 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 must be not zero. (The parameter is called "lambda", but that is a reserved word for 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 gamma function!) The parameters need to be set as follows: alpha > 0, or beta > 0..

Its probability distribution feature:

Notes on Reproducibility

Sometimes it is useful in order to reproduce the sequences produced by a pseudo-random generator. If you reuse a seed number and the same sequence, it 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 changes across Python versions, however two aspects are guaranteed not to change:

• If a different seeding method is added, then the backward compatible seeder will be available.
• Generator's random() method continues to produce the same sequence when the suitable seeder is provided with the same seed.