Genera un array casuale di float tra un intervallo

Non sono stato in grado di trovare una funzione per generare un array di float casuali di una data lunghezza tra un certo intervallo.

Ho esaminato il campionamento casuale ma nessuna funzione sembra fare quello che mi serve.

random.uniform si avvicina ma restituisce solo un singolo elemento, non un numero specifico.

Questo è quello che sto cercando:

ran_floats = some_function(low=0.5, high=13.3, size=50)

che restituirebbe un array di 50 float casuali non univoci (cioè: le ripetizioni sono consentite) distribuite uniformemente nell'intervallo [0.5, 13.3].

Esiste una tale funzione?

np.random.uniform si adatta al tuo caso d'uso:

sampl = np.random.uniform(low=0.5, high=13.3, size=(50,))

Aggiornamento ottobre 2019:

Sebbene la sintassi sia ancora supportata, sembra che l'API sia cambiata con NumPy 1.17 per supportare un maggiore controllo sul generatore di numeri casuali. Andando avanti l'API è cambiata e dovresti guardare https://docs.scipy.org/doc/numpy/reference/random/generated/numpy.random.Generator.uniform.html

La proposta di miglioramento è qui: https://numpy.org/neps/nep-0019-rng-policy.html

Perché non utilizzare una comprensione delle liste?

In Python 2

ran_floats = [random.uniform(low,high) for _ in xrange(size)]

In Python 3, rangefunziona come xrange( ref )

ran_floats = [random.uniform(low,high) for _ in range(size)]

Perché non combinare random.uniform con una lista di comprensione?

>>> def random_floats(low, high, size):
...    return [random.uniform(low, high) for _ in xrange(size)]
... 
>>> random_floats(0.5, 2.8, 5)
[2.366910411506704, 1.878800401620107, 1.0145196974227986, 2.332600336488709, 1.945869474662082]

Potrebbe già esserci una funzione per fare quello che stai cercando, ma non lo so (ancora?). Nel frattempo, suggerirei di utilizzare:

ran_floats = numpy.random.rand(50) * (13.3-0.5) + 0.5

Questo produrrà una matrice di forma (50,) con una distribuzione uniforme tra 0,5 e 13,3.

Potresti anche definire una funzione:

def random_uniform_range(shape=[1,],low=0,high=1):
    """
    Random uniform range

    Produces a random uniform distribution of specified shape, with arbitrary max and
    min values. Default shape is [1], and default range is [0,1].
    """
    return numpy.random.rand(shape) * (high - min) + min

EDIT : Hmm, sì, quindi l'ho perso, c'è numpy.random.uniform () con la stessa identica chiamata che vuoi! Prova import numpy; help(numpy.random.uniform)per maggiori informazioni.

Il ciclo for nella comprensione delle liste richiede tempo e lo rende lento. È meglio usare parametri numpy (basso, alto, dimensione, ..etc)

import numpy as np
import time
rang = 10000
tic = time.time()
for i in range(rang):
    sampl = np.random.uniform(low=0, high=2, size=(182))
print("it took: ", time.time() - tic)

tic = time.time()
for i in range(rang):
    ran_floats = [np.random.uniform(0,2) for _ in range(182)]
print("it took: ", time.time() - tic)

output di esempio:

('ci sono voluti:', 0,06406784057617188)

('ci sono voluti:', 1.7253198623657227)

In alternativa puoi usare SciPy

from scipy import stats
stats.uniform(0.5, 13.3).rvs(50)

e per il record per campionare interi è

stats.randint(10, 20).rvs(50)

Questo è il modo più semplice

np.random.uniform(start,stop,(rows,columns))

np.random.random_sample(size) genererà float casuali nell'intervallo semiaperto [0.0, 1.0).