random number generator

random ( random)Generate pseudo-random numbers

Original code Lib/random.py

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

For integers, there is uniform selection of an array. For sequences, there is a uniform selection of the randomelement as well as it is a method to generate a randompermutation of a list in-place, and a program for random sampling without replacing.

On the real line, there are tools that compute normal, uniform (Gaussian) Lognormal, Negative exponential, gamma, and beta distributions. For the purpose of generating distributions for angles such as it is possible to use the von Mises distribution is available.

Almost all modulefunctions depend on the basic function random() that generates a randomfloat evenly across the semi-open range [0.0, 1.0). Python utilizes to use the Mersenne Twister as the core generator. It produces precision floats of 53 bits and runs for 2**19937-1. The implementation that is underlying is written in C is both speedy and threadsafe. It is thread-safe and fast. Mersenne Twister is one of the most extensively testable random number generators in existence. It is however, because it is 100% deterministic, it is not ideal for every purpose as it is unsuitable for cryptographic use.

The functions in this module are bound methods that are a secret version of random. Randomclass. It is possible to instantiate your own instances of Random for generators that do not share state.

Class Random could be subclassed in the event that you require a completely different base generator from your own invention and in that instance, take over all of random() (), seed(), getstate(), and setstate() strategies. In addition, a different generator can supply an call to the getrandbits() method -it lets the randrange() to produce selections over an arbitrarily large range.

Random module also provides the random module also includes also the SystemRandom class, which utilizes an operating system feature called os.urandom() to create random numbers from data sources provided from the operating system.

Warning

The pseudo-random generators in this module are not suitable to secure your data. For use in cryptography or security you should refer to 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)

Initialize the random number generator.

If a is omitted or otherwise, none otherwise, the actual system clock is utilized. If randomness sources are made available through the OS, these sources will be used in place of that of the time in system (see the os.urandom() function for further information on their availability).

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

In version 2, (the default), a str, bytes, and bytearray object gets converted to an int and all its bits are utilized.

Version 1 (provided to replicate random sequences generated by older versions of Python) the algorithms used for str and bytes generates a narrower range of seeds.

Changed in version 3.2:Moved to the version 2 scheme that utilizes all the bits in 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()

A return object that captures the current internal situation of generator. This object can be passed to setstate() to restore the state.random.setstate(state)

state ought to have been retrieved by a previous call to obtain state(), and setstate() restores the internal state of the generator to what it was at the time when getstate() was called.

Functions for bytes

random. randbytes( n)

Generate nu random bytes.

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

The argument pattern for the positional argument is identical to the format of range(). Keyword arguments should not be used as the program may use them in unexpected ways.

It was updated since Version 3.2: randrange() is more advanced in producing evenly distributed values. The previous version used a style like int(random()*n) which could result in slightly different distributions.

Deprecated since 3.10 3.10: The automatic conversion of non-integer types into equivalent integers has been removed. Currently randrange(10.0) is losslessly converted to randrange(10). In the near future it will result in the possibility of 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 which is such that A= N <= b. Alias for randrange(a, b+1).random.getrandbits(k)

Returns an unnegative Python integer with k random bits. This function is provided by the MersenneTwister generator and other generators can also provide it as an additional feature within the API. If available, findrandbits() enables randrange() to handle the arbitrarily large ranges.

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

Sequences and functions

random. selection( seq)

Return the random item from non-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 from the population with replacement. If populace is empty, is raised indexError.

If a weights sequence is provided, the selections will be made based on 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, 5and 30] equal to the total weights [10 15 45 50[10, 15, 45, 50]. Internally all relative weights have been converted to cumulative weights prior to making choices, so supplying the cumulative weights is a way to save time.

If there is no weights or cum_weights are given, then selections are made with equal probabilities. If a weights series is supplied, it must have exactly the same length as the number of people in the sequence. It's a MethodError to define that both weighs as well as cum_weights.

Cum_weights and the the weights are also called cum_weights. cum_weights can be made using any numeric type that can be used to interoperate with floating values generated through random() (that includes integers, floats, as well as fractions, but excludes decimals). Weights are presumed to be non-negative and finite. It is a ValueError is raised if each weight is zero.

Based on a given seed using the choice() function with equal weighting typically produces distinct sequences than numerous calls to choices(). The algorithm used by choices() uses floating point arithmetic for internal uniformity and speed. The algorithm employed by selection() defaults to integer arithmetic , with repeated choices to prevent small deviations 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])

Shuffle the sequence in the sequence in place.

The optional argument random will be the function with 0 arguments that return the random floating value of [0.0, 1.0); by default, this functions as random().

To shuffle an immutable order and return a fresh to be shuffled, make use of sample(x, k=len(x)) instead.

It is important to note that even for tiny len(x), the total number of permutations of the x can be rapidly growing larger than the duration of the majority of random number generators. This means that the majority of the permutations in a long sequence can never be generated. As an example, a sequence of 2080 characters is the longest sequence that is possible to fit within the period 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 list of unique elements chosen from the set of elements or the population set. This is useful for random sampling with no replacement.

Returns a new list containing parts of the population, maintaining the original sample. The resultant list is created in selection order so that all sub-slices will have the same validity as random samples. This allows winners of raffles (the representative sample) to be divided 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 every occurrence of likely to be a selection within the sample.

Repeated elements are possible to specify one at a time or by using the optional keyword-only the counts parameter. For instance, sample(['red', 'blue'], counts=[4 2, 2], k=5) is equivalent to sample(['red','red', 'red' 'red', 'blue", "blue'count=[4, 2], k=5).

To select a suitable sample from an array of integers employ a 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 sample size is greater than the population size, there is a ValueError is raised.

Changed in version 3.9:Added the counts parameter.

No longer supported since the version 3.9: In the future the population will be a sequence. The instances within a set are no longer supported. The set should first be converted into the form of a array or tuple at least in an order that is predictable so that the set can be replicated.

Real-valued distributions

The following functions create specific real-valued distributions. Function parameters are named for the variables they correspond to in the equation of the distribution, as used in common mathematical practice The majority of these formulas can be found in any statistics text. 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 N = a= b, for a= b, and b= N <= a for b < a.

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 with low= N <means high and in the specified mode between those boundaries. This is because 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 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 that is not used by 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 of gamma!) The parameters need to be set as follows: beta > 0. and beta > 0..

A probability distribution formula:

Notes on Reproducibility

Sometimes, it's beneficial to be able to reproduce the sequences produced by a pseudo-random generator. By re-using a seed value, the same sequence should be reproducible from one run to the next running as long as several threads are not running.

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

• If a seeding option that is new is implemented, a backward-compatible seeder will be provided.
• A generator's random() method will produce exactly the same sequence when a appropriate seeder is given that same seed.