Python random number numpy

Random Generator#

The Generator provides access to a wide range of distributions, and served as a replacement for RandomState . The main difference between the two is that Generator relies on an additional BitGenerator to manage state and generate the random bits, which are then transformed into random values from useful distributions. The default BitGenerator used by Generator is PCG64 . The BitGenerator can be changed by passing an instantized BitGenerator to Generator .

numpy.random. default_rng ( seed = None ) #

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

A seed to initialize the BitGenerator . If None, then fresh, unpredictable entropy will be pulled from the OS. If an int or array_like[ints] is passed, then it will be passed to SeedSequence to derive the initial BitGenerator state. One may also pass in a SeedSequence instance. Additionally, when passed a BitGenerator , it will be wrapped by Generator . If passed a Generator , it will be returned unaltered.

The initialized generator object.

If seed is not a BitGenerator or a Generator , a new BitGenerator is instantiated. This function does not manage a default global instance.

See Seeding and Entropy for more information about seeding.

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

Here we use default_rng to generate a random float:

>>> import numpy as np >>> rng = np.random.default_rng(12345) >>> print(rng) Generator(PCG64) >>> rfloat = rng.random() >>> rfloat 0.22733602246716966 >>> type(rfloat)

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

>>> import numpy as np >>> rng = np.random.default_rng(12345) >>> rints = rng.integers(low=0, high=10, size=3) >>> rints array([6, 2, 7]) >>> type(rints[0])

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

>>> import numpy as np >>> rng = np.random.default_rng(seed=42) >>> print(rng) Generator(PCG64) >>> arr1 = rng.random((3, 3)) >>> arr1 array([[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 we generate the same random numbers again:

>>> import numpy as np >>> rng = np.random.default_rng(seed=42) >>> arr2 = rng.random((3, 3)) >>> arr2 array([[0.77395605, 0.43887844, 0.85859792], [0.69736803, 0.09417735, 0.97562235], [0.7611397 , 0.78606431, 0.12811363]]) 

Container for the BitGenerators.

Generator exposes a number of methods for generating random numbers drawn from a variety of probability distributions. In addition to the distribution-specific arguments, each method takes a keyword argument size that defaults to None . If size is None , then a single value is generated and returned. If size is an integer, then a 1-D array filled with generated values is returned. If size is a tuple, then an array with that shape is filled and returned.

The function numpy.random.default_rng will instantiate a Generator with numpy’s default BitGenerator .

No Compatibility Guarantee

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

Parameters : bit_generator BitGenerator

BitGenerator to use as the core generator.

Recommended constructor for Generator .

The Python stdlib module random contains pseudo-random number generator with a number of methods that are similar to the ones available in Generator . It uses Mersenne Twister, and this bit generator can be accessed using MT19937 . Generator , besides being NumPy-aware, has the advantage that it provides a much larger number of probability distributions to choose from.

>>> from numpy.random import Generator, PCG64 >>> rng = Generator(PCG64()) >>> rng.standard_normal() -0.203 # random 

Accessing the BitGenerator and Spawning#

Gets the bit generator instance used by the generator

Create new independent child generators.

Simple random data#

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

Return random integers from low (inclusive) to high (exclusive), or if endpoint=True, low (inclusive) to high (inclusive).

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

Permutations#

The methods for randomly permuting a sequence are

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

Randomly permute a sequence, or return a permuted range.

Randomly permute x along axis axis.

The following table summarizes the behaviors of the methods.

either (use ‘out’ for in-place)

The following subsections provide more details about the differences.

In-place vs. copy#

The main difference between Generator.shuffle and Generator.permutation is that Generator.shuffle operates in-place, while Generator.permutation returns a copy.

By default, Generator.permuted returns a copy. To operate in-place with Generator.permuted , pass the same array as the first argument and as the value of the out parameter. For example,

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

Note that when out is given, the return value is out :

Handling the axis parameter#

An important distinction for these methods is how they handle the axis parameter. Both Generator.shuffle and Generator.permutation treat the input as a one-dimensional sequence, and the axis parameter determines which dimension of the input array to use as the sequence. In the case of a two-dimensional array, axis=0 will, in effect, rearrange the rows of the array, and axis=1 will rearrange the columns. For example

>>> rng = np.random.default_rng() >>> x = np.arange(0, 15).reshape(3, 5) >>> x array([[ 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 within each column have not changed.

The method Generator.permuted treats the axis parameter similar to how numpy.sort treats it. Each slice along the given axis is shuffled independently of the others. Compare the following example of the use of Generator.permuted to the above example of Generator.permutation :

>>> 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 along axis=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 given a sequence that is not a NumPy array, it shuffles that sequence in-place. For example,

>>> 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#

Draw samples from a Beta distribution.

Draw samples from a binomial distribution.

Draw samples from a chi-square distribution.

Draw samples from the Dirichlet distribution.

Draw samples from an exponential distribution.

Draw samples from an F distribution.

Draw samples from a Gamma distribution.

Draw samples from the geometric distribution.

Draw samples from a Gumbel distribution.

Draw samples from a Hypergeometric distribution.

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

Draw samples from a logistic distribution.

Draw samples from a log-normal distribution.

Draw samples from a logarithmic series distribution.

Draw samples from a multinomial distribution.

Generate variates from a multivariate hypergeometric distribution.

Draw random samples from a multivariate normal distribution.

Draw samples from a negative binomial distribution.

Draw samples from a noncentral chi-square distribution.

Draw samples from the noncentral F distribution.

Draw random samples from a normal (Gaussian) distribution.

Draw samples from a Pareto II or Lomax distribution with specified shape.

Draw samples from a Poisson distribution.

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

Draw samples from a Rayleigh distribution.

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

Draw samples from the standard exponential distribution.

Draw samples from a standard Gamma distribution.

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

Draw samples from a standard Student’s t distribution with df degrees of freedom.

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

Draw samples from a uniform distribution.

Draw samples from a von Mises distribution.

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

Draw samples from a Weibull distribution.

Draw samples from a Zipf distribution.

Random sampling ( numpy.random )

Источник

Random Numbers in NumPy

Random number does NOT mean a different number every time. Random means something that can not be predicted logically.

Pseudo Random and True Random.

Computers work on programs, and programs are definitive set of instructions. So it means there must be some algorithm to generate a random number as well.

If there is a program to generate random number it can be predicted, thus it is not truly random.

Random numbers generated through a generation algorithm are called pseudo random.

Can we make truly random numbers?

Yes. In order to generate a truly random number on our computers we need to get the random data from some outside source. This outside source is generally our keystrokes, mouse movements, data on network etc.

We do not need truly random numbers, unless it is related to security (e.g. encryption keys) or the basis of application is the randomness (e.g. Digital roulette wheels).

In this tutorial we will be using pseudo random numbers.

Generate Random Number

NumPy offers the random module to work with random numbers.

Example

Generate a random integer from 0 to 100:

Generate Random Float

The random module’s rand() method returns a random float between 0 and 1.

Example

Generate a random float from 0 to 1:

Generate Random Array

In NumPy we work with arrays, and you can use the two methods from the above examples to make random arrays.

Integers

The randint() method takes a size parameter where you can specify the shape of an array.

Example

Generate a 1-D array containing 5 random integers from 0 to 100:

Example

Generate a 2-D array with 3 rows, each row containing 5 random integers from 0 to 100:

x = random.randint(100, size=(3, 5))

Floats

The rand() method also allows you to specify the shape of the array.

Example

Generate a 1-D array containing 5 random floats:

Example

Generate a 2-D array with 3 rows, each row containing 5 random numbers:

Generate Random Number From Array

The choice() method allows you to generate a random value based on an array of values.

The choice() method takes an array as a parameter and randomly returns one of the values.

Example

Return one of the values in an array:

The choice() method also allows you to return an array of values.

Add a size parameter to specify the shape of the array.

Example

Generate a 2-D array that consists of the values in the array parameter (3, 5, 7, and 9):

x = random.choice([3, 5, 7, 9], size=(3, 5))

Источник