Как использовать значение шага decimal range ()?

есть ли способ сделать шаг между 0 и 1 на 0.1?

Я думал, что смогу сделать это следующим образом, но это не удалось:

for i in range(0, 1, 0.1):
    print i

вместо этого он говорит, что аргумент шага не может быть нулевым, чего я не ожидал.

523
floating-point python range

30 ответов

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

можно использовать С включает в себя библиотека (которая не является частью стандартной библиотеки, но относительно легко получить). linspace принимает ряд точек для возврата, а также позволяет указать, следует ли включать право конечная точка:

>>> np.linspace(0,1,11)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])
>>> np.linspace(0,1,10,endpoint=False)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

если вы действительно хотите использовать значение шага с плавающей запятой, вы можете, с numpy.arange.

>>> import numpy as np
>>> np.arange(0.0, 1.0, 0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

ошибка округления с плавающей запятой будет вызвать проблемы, хотя. Вот простой случай, когда ошибка округления вызывает arange чтобы создать массив длины-4, когда он должен производить только 3 числа:

>>> numpy.arange(1, 1.3, 0.1)
array([1. , 1.1, 1.2, 1.3])
655

диапазон Python () может делать только целые числа, а не с плавающей запятой. В вашем конкретном случае вместо этого вы можете использовать понимание списка:

[x * 0.1 for x in range(0, 10)]

(замените вызов range этим выражением.)

для более общего случая вы можете написать пользовательскую функцию или генератор.

159

дом на ' xrange ([start], stop [, step])', вы можете определить генератор, который принимает и производит любой тип, который вы выбираете (придерживайтесь типов, поддерживающих + и <):

>>> def drange(start, stop, step):
...     r = start
...     while r < stop:
...         yield r
...         r += step
...         
>>> i0=drange(0.0, 1.0, 0.1)
>>> ["%g" % x for x in i0]
['0', '0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '1']
>>>
139

рост величины i для цикла, а затем уменьшить его, когда вам это нужно.

for i * 100 in range(0, 100, 10):
    print i / 100.0

EDIT: я честно не могу вспомнить, почему я думал, что это будет работать синтаксически

for i in range(0, 11, 1):
    print i / 10.0

Это должно иметь желаемый результат.

31

scipy имеет встроенную функцию arange обобщающее языка Python range() конструктор для того чтобы удовлетворять ваше требование регулировать поплавка.

from scipy import arange

21

NumPy немного перебор, я думаю.

[p/10 for p in range(0, 10)]
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

вообще говоря, делать шаг за-1/x до y вы могли бы сделать

x=100
y=2
[p/x for p in range(0, int(x*y))]
[0.0, 0.01, 0.02, 0.03, ..., 1.97, 1.98, 1.99]

(1/x произведенный меньше округляя шума когда я испытал).

19

аналогично Р seq функция, эта возвращает последовательность в любом порядке, заданном правильное значение шага. Последнее значение равно значению stop. 

def seq(start, stop, step=1):
    n = int(round((stop - start)/float(step)))
    if n > 1:
        return([start + step*i for i in range(n+1)])
    elif n == 1:
        return([start])
    else:
        return([])

результаты

seq(1, 5, 0.5)

[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

seq(10, 0, -1)

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

seq(10, 0, -2)

[10, 8, 6, 4, 2, 0]

seq(1, 1)

[ 1 ]

16

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

Я бы сказал просто использовать цикл while:

i = 0.0
while i <= 1.0:
    print i
    i += 0.1

Если вам интересно, Python преобразует ваш 0.1 в 0, поэтому он говорит вам, что аргумент не может быть равен нулю.

10
import numpy as np
for i in np.arange(0, 1, 0.1): 
    print i
9

вот решение, используя itertools:

import itertools

def seq(start, end, step):
    assert(step != 0)
    sample_count = abs(end - start) / step
    return itertools.islice(itertools.count(start, step), sample_count)

Пример Использования:

for i in seq(0, 1, 0.1):
    print i

выход:

0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
9
[x * 0.1 for x in range(0, 10)]

в Python 2.7 x дает результат:

[0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]

но если ты используешь:

[ round(x * 0.1, 1) for x in range(0, 10)]

дает вам желаемого:

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

7

и если вы делаете это часто, вы можете сохранить сгенерированный список r

r=map(lambda x: x/10.0,range(0,10))
for i in r:
    print i
5

мои версии используют исходную функцию диапазона для создания мультипликативных индексов для сдвига. Это позволяет использовать тот же синтаксис для исходной функции range. Я сделал две версии, одну с использованием float, а другую с использованием Decimal, потому что я обнаружил, что в некоторых случаях я хотел избежать дрейфа округления, введенного арифметикой с плавающей запятой.

это согласуется с пустыми результатами набора, как в range / xrange.

передает только одно числовое значение или функция верните выход стандартного диапазона к целочисленному потолочному значению входного параметра(поэтому, если вы дали ему 5.5, он вернет диапазон (6).)

Edit: код ниже теперь доступен как пакет на pypi:Franges

## frange.py
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def frange(start, stop = None, step = 1):
    """frange generates a set of floating point values over the 
    range [start, stop) with step size step

    frange([start,] stop [, step ])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # create a generator expression for the index values
        indices = (i for i in _xrange(0, int((stop-start)/step)))  
        # yield results
        for i in indices:
            yield start + step*i

## drange.py
import decimal
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def drange(start, stop = None, step = 1, precision = None):
    """drange generates a set of Decimal values over the
    range [start, stop) with step size step

    drange([start,] stop, [step [,precision]])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # find precision
        if precision is not None:
            decimal.getcontext().prec = precision
        # convert values to decimals
        start = decimal.Decimal(start)
        stop = decimal.Decimal(stop)
        step = decimal.Decimal(step)
        # create a generator expression for the index values
        indices = (
            i for i in _xrange(
                0, 
                ((stop-start)/step).to_integral_value()
            )
        )  
        # yield results
        for i in indices:
            yield float(start + step*i)

## testranges.py
import frange
import drange
list(frange.frange(0, 2, 0.5)) # [0.0, 0.5, 1.0, 1.5]
list(drange.drange(0, 2, 0.5, precision = 6)) # [0.0, 0.5, 1.0, 1.5]
list(frange.frange(3)) # [0, 1, 2]
list(frange.frange(3.5)) # [0, 1, 2, 3]
list(frange.frange(0,10, -1)) # []
4

Это мое решение для получения диапазонов с шагами float.
используя эту функцию, нет необходимости импортировать numpy или устанавливать его.
Я уверен, что его можно улучшить и оптимизировать. Не стесняйтесь делать это и размещать его здесь.

from __future__ import division
from math import log

def xfrange(start, stop, step):

    old_start = start #backup this value

    digits = int(round(log(10000, 10)))+1 #get number of digits
    magnitude = 10**digits
    stop = int(magnitude * stop) #convert from 
    step = int(magnitude * step) #0.1 to 10 (e.g.)

    if start == 0:
        start = 10**(digits-1)
    else:
        start = 10**(digits)*start

    data = []   #create array

    #calc number of iterations
    end_loop = int((stop-start)//step)
    if old_start == 0:
        end_loop += 1

    acc = start

    for i in xrange(0, end_loop):
        data.append(acc/magnitude)
        acc += step

    return data

print xfrange(1, 2.1, 0.1)
print xfrange(0, 1.1, 0.1)
print xfrange(-1, 0.1, 0.1)

выход:

[1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]
[-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0]
4

more_itertools является сторонней библиотекой, которая реализует numeric_range:

import more_itertools as mit


for x in mit.numeric_range(0, 1, 0.1):
    print("{:.1f}".format(x))

выход

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

этот инструмент также работает для Decimal и Fraction.

3

вы можете использовать эту функцию:

def frange(start,end,step):
    return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))
2

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

# floating point range
def frange(a, b, stp=1.0):
  i = a+stp/2.0
  while i<b:
    yield a
    a += stp
    i += stp

кроме того, numpy.arange можно использовать.

2

для полноты бутика, функциональное решение:

def frange(a,b,s):
  return [] if s > 0 and a > b or s < 0 and a < b or s==0 else [a]+frange(a+s,b,s)
2

Это можно сделать с помощью библиотеки Numpy. функция arange () позволяет выполнять шаги в float. Но он возвращает массив numpy, который можно преобразовать в list с помощью tolist () для нашего удобства.

for i in np.arange(0, 1, 0.1).tolist():
   print i
2

мой ответ аналогичен другим, использующим map (), без необходимости NumPy и без использования лямбды (хотя вы могли бы). Чтобы получить список значений float от 0.0 до t_max в шагах dt:

def xdt(n):
    return dt*float(n)
tlist  = map(xdt, range(int(t_max/dt)+1))
2

добавить автокоррекцию для возможности неправильного входа на шаг:

def frange(start,step,stop):
    step *= 2*((stop>start)^(step<0))-1
    return [start+i*step for i in range(int((stop-start)/step))]
1

мое решение:

def seq(start, stop, step=1, digit=0):
    x = float(start)
    v = []
    while x <= stop:
        v.append(round(x,digit))
        x += step
    return v
1

Лучшее Решение: нет ошибки округления
_________________________________________________________________________________

>>> step = .1
>>> N = 10     # number of data points
>>> [ x / pow(step, -1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

_________________________________________________________________________________

Или для заданного диапазона вместо заданных точек данных (например, непрерывная функция) используйте:

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step
>>> [ x / pow(step,-1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

для реализации функции: replace x / pow(step, -1) С f( x / pow(step, -1) ), и определить f.
Например:

>>> import math
>>> def f(x):
        return math.sin(x)

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step)
>>> [ f( x / pow(step,-1) ) for x in range(0, N + 1) ]

[0.0, 0.09983341664682815, 0.19866933079506122, 0.29552020666133955, 0.3894183423086505, 
 0.479425538604203, 0.5646424733950354, 0.644217687237691, 0.7173560908995228,
 0.7833269096274834, 0.8414709848078965]
1

start и stop включены, а не один или другой (обычно stop исключается) и без импорта, и с использованием генераторов

def rangef(start, stop, step, fround=5):
    """
    Yields sequence of numbers from start (inclusive) to stop (inclusive)
    by step (increment) with rounding set to n digits.

    :param start: start of sequence
    :param stop: end of sequence
    :param step: int or float increment (e.g. 1 or 0.001)
    :param fround: float rounding, n decimal places
    :return:
    """
    try:
        i = 0
        while stop >= start and step > 0:
            if i==0:
                yield start
            elif start >= stop:
                yield stop
            elif start < stop:
                if start == 0:
                    yield 0
                if start != 0:
                    yield start
            i += 1
            start += step
            start = round(start, fround)
        else:
            pass
    except TypeError as e:
        yield "type-error({})".format(e)
    else:
        pass


# passing
print(list(rangef(-100.0,10.0,1)))
print(list(rangef(-100,0,0.5)))
print(list(rangef(-1,1,0.2)))
print(list(rangef(-1,1,0.1)))
print(list(rangef(-1,1,0.05)))
print(list(rangef(-1,1,0.02)))
print(list(rangef(-1,1,0.01)))
print(list(rangef(-1,1,0.005)))
# failing: type-error:
print(list(rangef("1","10","1")))
print(list(rangef(1,10,"1")))

Python 3.6.2 (v3.6.2: 5fd33b5, июль 8 2017, 04:57:36) [MSC V. 1900 64 бит (для amd64)]

1

удивлен, что никто еще не упомянул рекомендуемое решение в документах Python 3:

Читайте также:

  • на рецепт linspace показывает, как реализовать ленивую версию диапазона, подходящую для приложений с плавающей запятой.

после определения, рецепт прост в использовании и не требует numpy или любые другие внешние библиотеки, но функции, такие как numpy.linspace(). Заметить что а не

1

чтобы противостоять проблемам точности поплавка, вы можете использовать Decimal модуль.

это требует дополнительных усилий для преобразования Decimal С int или float при написании кода, но вы можете пройти вместо str и измените функцию, если такое удобство действительно необходимо.

from decimal import Decimal
from decimal import Decimal as D


def decimal_range(*args):

    zero, one = Decimal('0'), Decimal('1')

    if len(args) == 1:
        start, stop, step = zero, args[0], one
    elif len(args) == 2:
        start, stop, step = args + (one,)
    elif len(args) == 3:
        start, stop, step = args
    else:
        raise ValueError('Expected 1 or 2 arguments, got %s' % len(args))

    if not all([type(arg) == Decimal for arg in (start, stop, step)]):
        raise ValueError('Arguments must be passed as <type: Decimal>')

    # neglect bad cases
    if (start == stop) or (start > stop and step >= zero) or \
                          (start < stop and step <= zero):
        return []

    current = start
    while abs(current) < abs(stop):
        yield current
        current += step

пример вывода -

list(decimal_range(D('2')))
# [Decimal('0'), Decimal('1')]
list(decimal_range(D('2'), D('4.5')))
# [Decimal('2'), Decimal('3'), Decimal('4')]
list(decimal_range(D('2'), D('4.5'), D('0.5')))
# [Decimal('2'), Decimal('2.5'), Decimal('3.0'), Decimal('3.5'), Decimal('4.0')]
list(decimal_range(D('2'), D('4.5'), D('-0.5')))
# []
list(decimal_range(D('2'), D('-4.5'), D('-0.5')))
# [Decimal('2'),
#  Decimal('1.5'),
#  Decimal('1.0'),
#  Decimal('0.5'),
#  Decimal('0.0'),
#  Decimal('-0.5'),
#  Decimal('-1.0'),
#  Decimal('-1.5'),
#  Decimal('-2.0'),
#  Decimal('-2.5'),
#  Decimal('-3.0'),
#  Decimal('-3.5'),
#  Decimal('-4.0')]
1

вот мое решение, которое отлично работает с float_range(-1, 0, 0.01) и работает без ошибок представление с плавающей точкой. Это не очень быстро, но работает отлично:

from decimal import Decimal

def get_multiplier(_from, _to, step):
    digits = []
    for number in [_from, _to, step]:
        pre = Decimal(str(number)) % 1
        digit = len(str(pre)) - 2
        digits.append(digit)
    max_digits = max(digits)
    return float(10 ** (max_digits))


def float_range(_from, _to, step, include=False):
    """Generates a range list of floating point values over the Range [start, stop]
       with step size step
       include=True - allows to include right value to if possible
       !! Works fine with floating point representation !!
    """
    mult = get_multiplier(_from, _to, step)
    # print mult
    int_from = int(round(_from * mult))
    int_to = int(round(_to * mult))
    int_step = int(round(step * mult))
    # print int_from,int_to,int_step
    if include:
        result = range(int_from, int_to + int_step, int_step)
        result = [r for r in result if r <= int_to]
    else:
        result = range(int_from, int_to, int_step)
    # print result
    float_result = [r / mult for r in result]
    return float_result


print float_range(-1, 0, 0.01,include=False)

assert float_range(1.01, 2.06, 5.05 % 1, True) ==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01, 2.06]

assert float_range(1.01, 2.06, 5.05 % 1, False)==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01]
0

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

Я тоже весьма ленив и поэтому мне было трудно написать свои собственные функции.

в основном то, что я сделал, изменилось мое xrange(0.0, 1.0, 0.01) to xrange(0, 100, 1) и использовал деление на 100.0 внутри цикла. Я также был обеспокоен, если будут ошибки округления. Поэтому я решил проверить, есть ли любой. Теперь я слышал, что если например 0.01 из расчета не совсем float 0.01 сравнение их должно вернуть False (если я ошибаюсь, пожалуйста, дайте мне знать).

поэтому я решил проверить, будет ли мое решение работать для моего диапазона, выполнив короткий тест:

for d100 in xrange(0, 100, 1):
    d = d100 / 100.0
    fl = float("0.00"[:4 - len(str(d100))] + str(d100))
    print d, "=", fl , d == fl

и он напечатал True для каждого.

теперь, если я получаю это совершенно неправильно, пожалуйста, дайте мне знать.

0

этот один лайнер не будет загромождать ваш код. Знак шаг параметр важен.

def frange(start, stop, step):
    return [x*step+start for x in range(0,round(abs((stop-start)/step)+0.5001),
        int((stop-start)/step<0)*-2+1)]
0

frange (старт, стоп, точность)

def frange(a,b,i):
    p = 10**i
    sr = a*p
    er = (b*p) + 1
    p = float(p)
    return map(lambda x: x/p, xrange(sr,er))

In >frange(-1,1,1)

Out>[-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
0