RandomGenerator#

TheGenerator provides access toa wide range of distributions, and served as a replacement forRandomState. The main difference betweenthe two is thatGenerator relies on an additional BitGenerator tomanage state and generate the random bits, which are then transformed intorandom values from useful distributions. The default BitGenerator used byGenerator isPCG64. The BitGeneratorcan be changed by passing an instantized BitGenerator toGenerator.

numpy.random.default_rng(seed=None)#

Construct a new Generator with the default BitGenerator (PCG64).

Parameters:
seed{None, int, array_like[ints], SeedSequence, BitGenerator, Generator, RandomState}, optional

A seed to initialize theBitGenerator. If None, then fresh,unpredictable entropy will be pulled from the OS. If anint orarray_like[ints] is passed, then all values must be non-negative and will bepassed toSeedSequence to derive the initialBitGenerator state. One may alsopass in aSeedSequence instance.Additionally, when passed aBitGenerator, it will be wrapped byGenerator. If passed aGenerator, it will be returned unaltered.When passed a legacyRandomState instance it will be coerced to aGenerator.

Returns:
Generator

The initialized generator object.

Notes

Ifseed is not aBitGenerator or aGenerator, a newBitGeneratoris instantiated. This function does not manage a default global instance.

SeeSeeding and entropy for more information about seeding.

Examples

default_rng is the recommended constructor for the random number classGenerator. Here are several ways we can construct a random number generator usingdefault_rng and theGenerator class.

Here we usedefault_rng to generate a random float:

>>>importnumpyasnp>>>rng=np.random.default_rng(12345)>>>print(rng)Generator(PCG64)>>>rfloat=rng.random()>>>rfloat0.22733602246716966>>>type(rfloat)<class 'float'>

Here we usedefault_rng to generate 3 random integers between 0 (inclusive) and 10 (exclusive):

>>>importnumpyasnp>>>rng=np.random.default_rng(12345)>>>rints=rng.integers(low=0,high=10,size=3)>>>rintsarray([6, 2, 7])>>>type(rints[0])<class 'numpy.int64'>

Here we specify a seed so that we have reproducible results:

>>>importnumpyasnp>>>rng=np.random.default_rng(seed=42)>>>print(rng)Generator(PCG64)>>>arr1=rng.random((3,3))>>>arr1array([[0.77395605, 0.43887844, 0.85859792],       [0.69736803, 0.09417735, 0.97562235],       [0.7611397 , 0.78606431, 0.12811363]])

If we exit and restart our Python interpreter, we’ll see that wegenerate the same random numbers again:

>>>importnumpyasnp>>>rng=np.random.default_rng(seed=42)>>>arr2=rng.random((3,3))>>>arr2array([[0.77395605, 0.43887844, 0.85859792],       [0.69736803, 0.09417735, 0.97562235],       [0.7611397 , 0.78606431, 0.12811363]])
classnumpy.random.Generator(bit_generator)#

Container for the BitGenerators.

Generator exposes a number of methods for generating randomnumbers drawn from a variety of probability distributions. In addition tothe distribution-specific arguments, each method takes a keyword argumentsize that defaults toNone. Ifsize isNone, then a singlevalue is generated and returned. Ifsize is an integer, then a 1-Darray filled with generated values is returned. Ifsize is a tuple,then an array with that shape is filled and returned.

The functionnumpy.random.default_rng will instantiateaGenerator with numpy’s defaultBitGenerator.

No Compatibility Guarantee

Generator does not provide a version compatibility guarantee. Inparticular, as better algorithms evolve the bit stream may change.

Parameters:
bit_generatorBitGenerator

BitGenerator to use as the core generator.

See also

default_rng

Recommended constructor forGenerator.

Notes

The Python stdlib modulerandom containspseudo-random number generator with a number of methods that are similarto the ones available inGenerator.It uses Mersenne Twister, and this bit generator canbe accessed usingMT19937.Generator, besides beingNumPy-aware, has the advantage that it provides a much larger numberof probability distributions to choose from.

Examples

>>>fromnumpy.randomimportGenerator,PCG64>>>rng=Generator(PCG64())>>>rng.standard_normal()-0.203  # random

Accessing the BitGenerator and spawning#

bit_generator

Gets the bit generator instance used by the generator

spawn(n_children)

Create new independent child generators.

Simple random data#

integers(low[, high, size, dtype, endpoint])

Return random integers fromlow (inclusive) tohigh (exclusive), or if endpoint=True,low (inclusive) tohigh (inclusive).

random([size, dtype, out])

Return random floats in the half-open interval [0.0, 1.0).

choice(a[, size, replace, p, axis, shuffle])

Generates a random sample from a given array

bytes(length)

Return random bytes.

Permutations#

The methods for randomly permuting a sequence are

shuffle(x[, axis])

Modify an array or sequence in-place by shuffling its contents.

permutation(x[, axis])

Randomly permute a sequence, or return a permuted range.

permuted(x[, axis, out])

Randomly permutex along axisaxis.

The following table summarizes the behaviors of the methods.

method

copy/in-place

axis handling

shuffle

in-place

as if 1d

permutation

copy

as if 1d

permuted

either (use ‘out’for in-place)

axis independent

The following subsections provide more details about the differences.

In-place vs. copy#

The main difference betweenGenerator.shuffle andGenerator.permutationis thatGenerator.shuffle operates in-place, whileGenerator.permutationreturns a copy.

By default,Generator.permuted returns a copy. To operate in-place withGenerator.permuted, pass the same array as the first argumentand asthe value of theout parameter. For example,

>>>importnumpyasnp>>>rng=np.random.default_rng()>>>x=np.arange(0,15).reshape(3,5)>>>xarray([[ 0,  1,  2,  3,  4],       [ 5,  6,  7,  8,  9],       [10, 11, 12, 13, 14]])>>>y=rng.permuted(x,axis=1,out=x)>>>xarray([[ 1,  0,  2,  4,  3],  # random       [ 6,  7,  8,  9,  5],       [10, 14, 11, 13, 12]])

Note that whenout is given, the return value isout:

>>>yisxTrue

Handling theaxis parameter#

An important distinction for these methods is how they handle theaxisparameter. BothGenerator.shuffle andGenerator.permutation treat theinput as a one-dimensional sequence, and theaxis parameter determineswhich dimension of the input array to use as the sequence. In the case of atwo-dimensional array,axis=0 will, in effect, rearrange the rows of thearray, andaxis=1 will rearrange the columns. For example

>>>importnumpyasnp>>>rng=np.random.default_rng()>>>x=np.arange(0,15).reshape(3,5)>>>xarray([[ 0,  1,  2,  3,  4],       [ 5,  6,  7,  8,  9],       [10, 11, 12, 13, 14]])>>>rng.permutation(x,axis=1)array([[ 1,  3,  2,  0,  4],  # random       [ 6,  8,  7,  5,  9],       [11, 13, 12, 10, 14]])

Note that the columns have been rearranged “in bulk”: the values withineach column have not changed.

The methodGenerator.permuted treats theaxis parameter similar tohownumpy.sort treats it. Each slice along the given axis is shuffledindependently of the others. Compare the following example of the use ofGenerator.permuted to the above example ofGenerator.permutation:

>>>importnumpyasnp>>>rng=np.random.default_rng()>>>rng.permuted(x,axis=1)array([[ 1,  0,  2,  4,  3],  # random       [ 5,  7,  6,  9,  8],       [10, 14, 12, 13, 11]])

In this example, the values within each row (i.e. the values alongaxis=1) have been shuffled independently. This is not a “bulk”shuffle of the columns.

Shuffling non-NumPy sequences#

Generator.shuffle works on non-NumPy sequences. That is, if it is givena sequence that is not a NumPy array, it shuffles that sequence in-place.

>>>importnumpyasnp>>>rng=np.random.default_rng()>>>a=['A','B','C','D','E']>>>rng.shuffle(a)# shuffle the list in-place>>>a['B', 'D', 'A', 'E', 'C']  # random

Distributions#

beta(a, b[, size])

Draw samples from a Beta distribution.

binomial(n, p[, size])

Draw samples from a binomial distribution.

chisquare(df[, size])

Draw samples from a chi-square distribution.

dirichlet(alpha[, size])

Draw samples from the Dirichlet distribution.

exponential([scale, size])

Draw samples from an exponential distribution.

f(dfnum, dfden[, size])

Draw samples from an F distribution.

gamma(shape[, scale, size])

Draw samples from a Gamma distribution.

geometric(p[, size])

Draw samples from the geometric distribution.

gumbel([loc, scale, size])

Draw samples from a Gumbel distribution.

hypergeometric(ngood, nbad, nsample[, size])

Draw samples from a Hypergeometric distribution.

laplace([loc, scale, size])

Draw samples from the Laplace or double exponential distribution with specified location (or mean) and scale (decay).

logistic([loc, scale, size])

Draw samples from a logistic distribution.

lognormal([mean, sigma, size])

Draw samples from a log-normal distribution.

logseries(p[, size])

Draw samples from a logarithmic series distribution.

multinomial(n, pvals[, size])

Draw samples from a multinomial distribution.

multivariate_hypergeometric(colors, nsample)

Generate variates from a multivariate hypergeometric distribution.

multivariate_normal(mean, cov[, size, ...])

Draw random samples from a multivariate normal distribution.

negative_binomial(n, p[, size])

Draw samples from a negative binomial distribution.

noncentral_chisquare(df, nonc[, size])

Draw samples from a noncentral chi-square distribution.

noncentral_f(dfnum, dfden, nonc[, size])

Draw samples from the noncentral F distribution.

normal([loc, scale, size])

Draw random samples from a normal (Gaussian) distribution.

pareto(a[, size])

Draw samples from a Pareto II (AKA Lomax) distribution with specified shape.

poisson([lam, size])

Draw samples from a Poisson distribution.

power(a[, size])

Draws samples in [0, 1] from a power distribution with positive exponent a - 1.

rayleigh([scale, size])

Draw samples from a Rayleigh distribution.

standard_cauchy([size])

Draw samples from a standard Cauchy distribution with mode = 0.

standard_exponential([size, dtype, method, out])

Draw samples from the standard exponential distribution.

standard_gamma(shape[, size, dtype, out])

Draw samples from a standard Gamma distribution.

standard_normal([size, dtype, out])

Draw samples from a standard Normal distribution (mean=0, stdev=1).

standard_t(df[, size])

Draw samples from a standard Student's t distribution withdf degrees of freedom.

triangular(left, mode, right[, size])

Draw samples from the triangular distribution over the interval[left,right].

uniform([low, high, size])

Draw samples from a uniform distribution.

vonmises(mu, kappa[, size])

Draw samples from a von Mises distribution.

wald(mean, scale[, size])

Draw samples from a Wald, or inverse Gaussian, distribution.

weibull(a[, size])

Draw samples from a Weibull distribution.

zipf(a[, size])

Draw samples from a Zipf distribution.