Générer un tableau aléatoire de flottants entre une plage

Je n'ai pas été en mesure de trouver une fonction pour générer un tableau de flottants aléatoires d'une longueur donnée entre une certaine plage.

J'ai regardé l' échantillonnage aléatoire mais aucune fonction ne semble faire ce dont j'ai besoin.

random.uniform se rapproche mais il ne renvoie qu'un seul élément, pas un nombre spécifique.

Voici ce que je recherche:

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

qui renverrait un tableau de 50 flotteurs aléatoires non uniques (c'est-à-dire: les répétitions sont autorisées) uniformément répartis dans la plage [0.5, 13.3].

Existe-t-il une telle fonction?

np.random.uniform correspond à votre cas d'utilisation:

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

Mise à jour d'octobre 2019:

Bien que la syntaxe soit toujours prise en charge, il semble que l'API ait changé avec NumPy 1.17 pour prendre en charge un plus grand contrôle sur le générateur de nombres aléatoires. À l'avenir, l'API a changé et vous devriez regarder https://docs.scipy.org/doc/numpy/reference/random/generated/numpy.random.Generator.uniform.html

La proposition d'amélioration est ici: https://numpy.org/neps/nep-0019-rng-policy.html

Pourquoi ne pas utiliser une compréhension de liste?

Dans Python 2

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

En Python 3, rangefonctionne comme xrange( ref )

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

Pourquoi ne pas combiner random.uniform avec une compréhension de liste?

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

Il y a peut-être déjà une fonction pour faire ce que vous cherchez, mais je ne sais pas (encore?). En attendant, je suggérerais d'utiliser:

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

Cela produira un tableau de formes (50,) avec une distribution uniforme entre 0,5 et 13,3.

Vous pouvez également définir une fonction:

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, oui, donc je l'ai manqué, il y a numpy.random.uniform () avec le même appel exact que vous voulez! Essayez import numpy; help(numpy.random.uniform)pour plus d'informations.

La boucle for dans la compréhension de liste prend du temps et la ralentit. Il est préférable d'utiliser des paramètres numpy (faible, élevé, taille, ..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)

exemple de sortie:

('il a fallu:', 0.06406784057617188)

('il a fallu:', 1.7253198623657227)

Vous pouvez également utiliser SciPy

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

et pour que l'enregistrement échantillonne des entiers, c'est

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

C'est le moyen le plus simple

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

np.random.random_sample(size) générera des flottants aléatoires dans l'intervalle semi-ouvert [0.0, 1.0).