диапазона с шагом типа поплавка

Question

The documentation в основном говорит, что range должны вести себя именно так, как эту реализацию (для положительного step):

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

Он также говорит, что его аргументы должны быть целыми числами. Почему это? Разве это определение не является абсолютно корректным, если шаг является поплавком?

В моем случае, я особенно. нуждающаяся в функции range, которая принимает тип float как свой аргумент step. Есть ли в Python или мне нужно реализовать свои собственные?

---

Более конкретно: Как бы перевести этот код C непосредственно на Python хорошим способом (т.е. не просто делать это через while -loop вручную):

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

Answer 1

Вы можете использовать numpy.arange.

EDIT: Документы предпочитают numpy.linspace. _{Thanks @Droogans for noticeing =)}

Answer 2

Вероятно потому, что вы можете» t имеют часть итерации. Кроме того, floats являются неточными.

Answer 3

Когда вы добавляете числа с плавающей точкой вместе, часто возникает небольшая ошибка. Будет ли range(0.0, 2.2, 1.1) возвращаться [0.0, 1.1] или [0.0, 1.1, 2.199999999]? Нельзя быть уверенным без тщательного анализа.

Код, который вы опубликовали, является ОК, если вам это действительно нужно. Просто знайте о возможных недостатках.

Answer 4

Одним из объяснений может быть проблема округления с плавающей точкой. Например, если вы могли бы назвать

range(0, 0.4, 0.1) 

можно было бы ожидать выход

[0, 0.1, 0.2, 0.3] 

но вы на самом деле получить что-то вроде

[0, 0.1, 0.2000000001, 0.3000000001] 

из-за округления вопросов. А поскольку диапазон часто используется для генерации индексов какого-то типа, это целые числа.

Тем не менее, если вы хотите генератор диапазона для поплавков, вы можете просто свернуть свой собственный.

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

Answer 5

Проблема с плавающей точкой заключается в том, что вы не можете получить такое же количество элементов, как вы ожидали, из-за неточности. Это может быть реальной проблемой, если вы играете с многочленами, где точное количество элементов весьма важно.

Что вы действительно хотите, это арифметическая прогрессия; следующий код будет работать довольно успешно для int, float и complex ... и строк и списков ...

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

Обратите внимание, что этот код имеет больше шансов на ваш последний показатель, находящийся в рев быка от ожидаемого значения, чем любая альтернатива, которая поддерживает запущенную всего.

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

Исправление: вот 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

Для того, чтобы иметь возможность использовать десятичных чисел в выражении диапазона прохладный путь сделать это состоит в следующем: [х * 0,1 для х в диапазоне (0, 10)]

Answer 7

Вот особый случай, который может быть достаточно хорошим:

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

В вашем случае это будет:

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

и так:

>>> [ .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

Это то, что я хотел бы использовать:

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

, а не:

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] 

надеюсь, что он LPS.