How does python generate 5 random numbers?

Bookkeeping functions¶

Initialize the random number generator.

If a is omitted or None, the current system time is used. If randomness sources are provided by the operating system, they are used instead of the system time [see the os.urandom[] function for details on availability].

If a is an int, it is used directly.

With version 2 [the default], a str, bytes, or bytearray object gets converted to an int and all of its bits are used.

With version 1 [provided for reproducing random sequences from older versions of Python], the algorithm for str and bytes generates a narrower range of seeds.

Changed in version 3.2: Moved to the version 2 scheme which uses all of the bits in a 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.

Return an object capturing the current internal state of the generator. This object can be passed to setstate[] to restore the state.

state should have been obtained from a previous call to getstate[], and setstate[] restores the internal state of the generator to what it was at the time getstate[] was called.

Functions for bytes¶

Generate n random bytes.

This method should not be used for generating security tokens. Use secrets.token_bytes[] instead.

New in version 3.9.

Functions for integers¶

Return a randomly selected element from range[start, stop, step]. This is equivalent to choice[range[start, stop, step]], but doesn’t actually build a range object.

The positional argument pattern matches that of range[]. Keyword arguments should not be used because the function may use them in unexpected ways.

Changed in version 3.2: randrange[] is more sophisticated about producing equally distributed values. Formerly it used a style like int[random[]*n] which could produce slightly uneven distributions.

Deprecated since version 3.10: The automatic conversion of non-integer types to equivalent integers is deprecated. Currently randrange[10.0] is losslessly converted to randrange[10]. In the future, this will raise a 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.

Return a random integer N such that a expovariate[1 / 5] # Interval between arrivals averaging 5 seconds 5.148957571865031 >>> randrange[10] # Integer from 0 to 9 inclusive 7 >>> randrange[0, 101, 2] # Even integer from 0 to 100 inclusive 26 >>> choice[['win', 'lose', 'draw']] # Single random element from a sequence 'draw' >>> deck = 'ace two three four'.split[] >>> shuffle[deck] # Shuffle a list >>> deck ['four', 'two', 'ace', 'three'] >>> sample[[10, 20, 30, 40, 50], k=4] # Four samples without replacement [40, 10, 50, 30]

Simulations:

>>> # Six roulette wheel spins [weighted sampling with replacement]
>>> choices[['red', 'black', 'green'], [18, 18, 2], k=6]
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.count['tens'] / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean[drug] - mean[placebo]

n = 10_000
count = 0
combined = drug + placebo
for i in range[n]:
    shuffle[combined]
    new_diff = mean[combined[:len[drug]]] - mean[combined[len[drug]:]]
    count += [new_diff >= observed_diff]

print[f'{n} label reshufflings produced only {count} instances with a difference']
print[f'at least as extreme as the observed difference of {observed_diff:.1f}.']
print[f'The one-sided p-value of {count / n:.4f} leads us to reject the null']
print[f'hypothesis that there is no difference between the drug and the placebo.']

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

Recipes¶

The default random[] returns multiples of 2⁻⁵³ in the range 0.0 ≤ x < 1.0. All such numbers are evenly spaced and are exactly representable as Python floats. However, many other representable floats in that interval are not possible selections. For example, 0.05954861408025609 isn’t an integer multiple of 2⁻⁵³.

The following recipe takes a different approach. All floats in the interval are possible selections. The mantissa comes from a uniform distribution of integers in the range 2⁵² ≤ mantissa < 2⁵³. The exponent comes from a geometric distribution where exponents smaller than -53 occur half as often as the next larger exponent.

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

All real valued distributions in the class will use the new method:

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544

The recipe is conceptually equivalent to an algorithm that chooses from all the multiples of 2⁻¹⁰⁷⁴ in the range 0.0 ≤ x < 1.0. All such numbers are evenly spaced, but most have to be rounded down to the nearest representable Python float. [The value 2⁻¹⁰⁷⁴ is the smallest positive unnormalized float and is equal to math.ulp[0.0].]