web-dev-qa-db-fra.com

Faire une liste de nombres régulièrement espacés dans une certaine plage en python

Quelle est une façon Pythonique de faire une liste de longueur arbitraire contenant des nombres régulièrement espacés (pas seulement des entiers entiers) entre des bornes données? Par exemple:

my_func(0,5,10) # ( lower_bound , upper_bound , length )
# [ 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5 ]

Notez que la fonction Range() ne traite que les entiers. Et ça:

def my_func(low,up,leng):
    list = []
    step = (up - low) / float(leng)
    for i in range(leng):
        list.append(low)
        low = low + step
    return list

semble trop compliqué. Des idées?

listrangepython
36
Double AA

Étant donné numpy, vous pouvez utiliser linspace :

Y compris le point final droit (5):

In [46]: import numpy as np
In [47]: np.linspace(0,5,10)
Out[47]: 
array([ 0.        ,  0.55555556,  1.11111111,  1.66666667,  2.22222222,
        2.77777778,  3.33333333,  3.88888889,  4.44444444,  5.        ])

Exclusion du bon point de terminaison:

In [48]: np.linspace(0,5,10,endpoint=False)
Out[48]: array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])
56
unutbu

Vous pouvez utiliser l'approche suivante:

[lower + x*(upper-lower)/length for x in range(length)]

inférieur et/ou supérieur doivent être affectés comme flotteurs pour que cette approche fonctionne.

31
Howard

Semblable à la réponse d'unutbu, vous pouvez utiliser la fonction arange de numpy, qui est analogue à la fonction intrinsèque de Python range. Notez que le point final n'est pas inclus, comme dans range:

>>> import numpy as np
>>> a = np.arange(0,5, 0.5)
>>> a
array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])
>>> a = np.arange(0,5, 0.5) # returns a numpy array
>>> a
array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])
>>> a.tolist() # if you prefer it as a list
[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
7
milancurcic
f = 0.5
a = 0
b = 9
d = [x * f for x in range(a, b)]

serait un moyen de le faire.

2
marc

Vous pouvez utiliser le code suivant:

def float_range(initVal, itemCount, step):
    for x in xrange(itemCount):
        yield initVal
        initVal += step

[x for x in float_range(1, 3, 0.1)]
1
Artsiom Rudzenka

La fonction de commodité r_ de Numpy peut également créer des listes régulièrement espacées avec la syntaxe np.r_[start:stop:steps]. Si steps est un nombre réel (se terminant par j), alors le point final est inclus, équivalent à np.linspace(start, stop, step, endpoint=1), sinon non.

>>> np.r_[-1:1:6j, [0]*3, 5, 6]
array([-1. , -0.6, -0.2,  0.2,  0.6,  1.])

Vous pouvez également concatente directement d'autres tableaux et scalaires:

>>> np.r_[-1:1:6j, [0]*3, 5, 6]
array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])
0
Robin Dinse

Similaire à la réponse d'Howard mais un peu plus efficace:

def my_func(low, up, leng):
    step = ((up-low) * 1.0 / leng)
    return [low+i*step for i in xrange(leng)]
0
Peter Collingridge