Rango con el paso de tipo float

Question

The documentation básicamente dice que range debe comportarse exactamente como esta implementación (por step positivo):

def range(start, stop, step): 
    x = start 
    while True: 
    if x >= stop: return 
    yield x 
    x += step 

También dice que sus argumentos deben ser números enteros. ¿Porqué es eso? ¿No es esa definición también perfectamente válida si el paso es un flotador?

En mi caso, estoy especialmente. que necesita una función range que acepta un tipo de letra flotante como su argumento step. ¿Hay alguno en Python o necesito implementar el mío?

---

más específica: ¿Cómo voy a traducir el código C directamente a Python de una manera agradable (es decir, no sólo lo hace a través de un while lazos en forma manual):

for(float x = 0; x < 10; x += 0.5f) { /* ... */ } 

Answer 1

Puede usar numpy.arange.

EDITAR: Los documentos prefieren numpy.linspace. _{Gracias @Droogans para tener en cuenta =)}

Answer 2

Probablemente porque se puede' t tiene parte de un iterable. Además, floats son imprecisos.

Answer 3

Cuando agrega números flotantes juntos, a menudo hay un poco de error. ¿Un range(0.0, 2.2, 1.1) devolvería [0.0, 1.1] o [0.0, 1.1, 2.199999999]? No hay forma de estar seguro sin un análisis riguroso.

El código que ha publicado es una buena solución si realmente lo necesita. Solo tenga en cuenta las posibles deficiencias.

Answer 4

Una explicación podría ser problemas de redondeo de coma flotante. Por ejemplo, si se puede llamar

range(0, 0.4, 0.1) 

se podría esperar una producción de

[0, 0.1, 0.2, 0.3] 

pero en realidad se trata de algo así como

[0, 0.1, 0.2000000001, 0.3000000001] 

debido a problemas de redondeo. Y dado que el rango se usa a menudo para generar índices de algún tipo, solo es un número entero.

Aún así, si desea un generador de rango para flotadores, puede simplemente hacer el suyo.

def xfrange(start, stop, step): 
    i = 0 
    while start + i * step < stop: 
     yield start + i * step 
     i += 1 

Answer 5

El problema con el punto flotante es que es posible que no obtenga el mismo número de elementos que esperaba debido a la inexactitud. Esto puede ser un problema real si juegas con polinomios donde la cantidad exacta de elementos es bastante importante.

Lo que realmente quieres es una progresión aritmética; el siguiente código funcionará muy felizmente para int, float y complex ... y cadenas, y listas ...

def arithmetic_progression(start, step, length): 
    for i in xrange(length): 
     yield start + i * step 

Tenga en cuenta que este código tiene una mejor oportunidad de su último valor está dentro rugido de un toro del valor esperado que cualquier otra alternativa que mantiene un total acumulado.

>>> 10000 * 0.0001, sum(0.0001 for i in xrange(10000)) 
(1.0, 0.9999999999999062) 
>>> 10000 * (1/3.), sum(1/3. for i in xrange(10000)) 
(3333.333333333333, 3333.3333333337314) 

Corrección: aquí hay un competetive running-total gadget:

def kahan_range(start, stop, step): 
    assert step > 0.0 
    total = start 
    compo = 0.0 
    while total < stop: 
     yield total 
     y = step - compo 
     temp = total + y 
     compo = (temp - total) - y 
     total = temp 

>>> list(kahan_range(0, 1, 0.0001))[-1] 
0.9999 
>>> list(kahan_range(0, 3333.3334, 1/3.))[-1] 
3333.333333333333 
>>> 

Answer 6

Con el fin de ser capaz de utilizar los números decimales en una expresión de rango de una manera fresca para hacerlo es la siguiente: [x * 0.1 para x en el rango (0, 10)]

Answer 7

Aquí es un caso especial que podría ser lo suficientemente bueno:

[ (1.0/divStep)*x for x in range(start*divStep, stop*divStep)] 

En su caso esto sería:

#for(float x = 0; x < 10; x += 0.5f) { /* ... */ } ==> 
start = 0 
stop = 10 
divstep = 1/.5 = 2 #This needs to be int, thats why I said 'special case' 

y así:

>>> [ .5*x for x in range(0*2, 10*2)] 
[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5] 

Answer 8

Esto es lo que yo usaría:

numbers = [float(x)/10 for x in range(10)] 

en lugar de:

numbers = [x*0.1 for x in range(10)] 
that would return : 
[0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9] 

espero que él lps.