BMI Calculator

random -- Generate pseudo-random numbers

Source code: Lib/random.py

The module implementspseudoto implement random number generators for various distributions.

For integers, there is a uniform selection of an array. For sequences, there is a uniform selection of a randomelement and an algorithm to generate a randompermutation of a list in-place, and a method for random sampling with no replacement.

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

A majority of modulefunctions All modulefunctions rely on the modulefunction random(), which generates a randomfloat uniformly in the semi-open range [0.0, 1.0). Python employs an algorithm called the Mersenne Twister as the core generator. It creates floats with 53 bits of precision and has a timer of 2**19937-1. The core implementation in C is both fast and thread-safe. The Mersenne Twister is one of the most extensively tested random number generators in existence. However, being completely reliable, it's not ideal for every purpose and is not suitable to be used for cryptographic purposes.

The functions supplied by this module are actually bound methods for a hidden version of random. Randomclass. You can build your own instances for Random to generate generators that do not share state.

Class Random could be subclassed in the event that you prefer to utilize a different basic generator from your own invention in which case you override these methods to override the random() or seed() getstate() as well as getstate(), setstate() method. A new generator can supply the obtainrandbits() method -it lets rundrange() to produce options that cover an arbitrarily broad range.

It also includes the random module additionally provides also the SystemRandom class which uses its system functions os.urandom() to create random numbers from the sources supplied by the operating system.

Warning

The pseudo-random generators within this module are not suitable to protect yourself. For security or cryptographic uses 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 the random number generator.

If an option is left out or None, the present system's time will be used. If randomness sources are provided in the system by operating systems, they will be employed instead of timings set by the operating system (see for the os.urandom() function for details on availability).

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

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

With version 1 (provided to reproduce random sequences from older versions of Python) The algorithm that is used to compute str and bytes yields a smaller number of seeds.

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

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

state should have been obtained by a previous call to findstate(), 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 an amount of 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 a randomly selected element from range(start stopping, step). This is the same as choice(range(start stop, start, step)), but it doesn't create the range object.

The argument pattern for the positional argument is identical to the pattern of range(). Keyword arguments shouldn't be used, as the function may use them in unexpected ways.

Changed since Version 3.2: randrange() is more sophisticated about producing equally distributed values. Before, it employed a similar style to int(random()*n) which produced slightly different distributions.

The format is deprecated as of Version 3.10: The automatic conversion of non-integer type types to equivalent integers is deprecated. At present, randrange(10.0) is lostlessly converted to randrange(10). In the 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 an random numbers N which is such that the number a is greater than b. Alias for randrange(a, b+1).random.getrandbits(k)

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

Updated at Version 3.9:This method now accepts zero as the word k.

Functions for sequences

random. choice( seq)

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

Return a k size list of elements that are selected in the population with replacement. In case the number of elements is not filled, the program raises IndicateError.

If a weights sequence is defined, selections are made in accordance with 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, 5, etc.and 30] are equivalent to the cumulative weights [10, 15, 45 50for example]. Internally all relative weights have been converted into cumulative weights prior to making choices by supplying the cumulative weights will save time.

If there is no weights or cum_weights are specified, selections can be made with equal likelihood. If a weights series is specified, it must be exactly the same length as the number of people in the sequence. It's a kind of error to define cum_weights as well as weighs as well as cum_weights.

The weighs or cum_weights can be made using any numeric type that interoperates with the floating values returned to random() (that includes integers, floating points, and fractions, but not decimals). Weights are believed to be non-negative and finite. ValueError is raised if ValueError is raised if each weight is zero.

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

New in version 3.6.

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

The sequence is shuffled by x in the same place.

The optional argument random can be a 0-argument function returning an random floating value of [0.0, 1.0); by default, this happens to be the method random().

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

Noting that even for a tiny len(x), the number of permutations of the sequence will rapidly increase to be larger than the period of most random number generators. That means that the vast majority of permutations of a long sequence can never be created. For example, a sequence that is 2080 in length is the longest that fits within the time frame 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 number of length list of unique elements chosen from the population sequence or set. Used to perform random sampling, without replacement.

Returns a new list containing elements from the population while remaining the original population as is. The list generated is then in selection order so the sub-slices of all be valid random samples. This allows raffle winners (the sampling) to be separated into grand prize winners and second prize winners (the subslices).

Members of the population need not be unique or hashable. If the population has repeats, then each occurrence is a possible selection in the sample.

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

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

changed in version 3.9:Added the counts parameter.

Deprecated since version 3.9: In the future it is expected that the population must be a sequence. The instances in the form of set are not supported anymore. The set must be converted into an list or tuple, preferably in the same order to ensure that the set can be replicated.

Real-valued distributions

The following functions produce specific real-valued distributions. Function parameters are named for the variables that are corresponding to the distribution's equation, as commonly used in mathematical practices 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 N = a= b for a <= b, and b= N <+ 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 number N which is low= N <is high and with the specified modus between these boundaries. Both the high as well as the high bounds 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. Conditions on the parameters are alpha > 0, as well as beta > 0. Returned values range between 0 and 1.random.expovariate(lambd)

Exponential distribution. lambd is 1.0 divided by the desired median. It should be nonzero. (The parameter is referred to as "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 function of gamma!) The parameters must be in the range of alpha > zero or beta > 0..

A probability distribution formula is:

Notes on Reproducibility

Sometimes, it's beneficial for a reproducible version of the sequences provided by a pseudo-random number generator. By re-using a seed value this sequence will be reproducible from run to the next, as long as there are no multiple threads are not running.

The majority of random module's algorithms and seeding algorithms are subject to changes across Python versions, but two elements are guaranteed not to remain the same:

• If a new method of seeding is implemented, the backward compatible seeder will be provided.
• The generator's random() method continues to produce the same sequence when the suitable seeder is provided with the same seed.