Как использовать значение шага десятичного диапазона()?
https://stackoverflow.com/questions/477486
-
20-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Есть ли способ перейти от 0 к 1 на 0,1?
Я думал, что смогу сделать это следующим образом, но это не удалось:
for i in range(0, 1, 0.1):
print i
Вместо этого он говорит, что аргумент шага не может быть нулевым, чего я не ожидал.
Решение
Вместо того чтобы использовать десятичный шаг напрямую, гораздо безопаснее выразить это в виде количества точек, которые вы хотите получить. В противном случае ошибка округления с плавающей точкой может привести к неверному результату.
Вы можете использовать функцию linspace из библиотеки NumPy (которая не является частью стандартной библиотеки, но относительно легко получить). numpy.arange возвращает количество точек для возврата, а также позволяет указать, следует ли включать правильную конечную точку:
>>> 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])
Если вы действительно хотите использовать значение шага с плавающей запятой, вы можете с помощью 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])
Ошибка округления с плавающей точкой приведет к возникновению проблем. Вот простой случай, когда из-за ошибки округления <=> получается массив длины 4, когда он должен содержать только 3 числа:
>>> numpy.arange(1, 1.3, 0.1)
array([1. , 1.1, 1.2, 1.3])
Другие советы
Python range () может делать только целые числа, а не с плавающей точкой. В вашем конкретном случае вы можете вместо этого использовать понимание списка:
[x * 0.1 for x in range(0, 10)]
(Замените вызов range этим выражением.)
В более общем случае вы можете написать пользовательскую функцию или генератор.
Использование 'xrange ([начало], остановка [, шаг])' , вы можете определить генератор, который принимает и производит любой тип по вашему выбору (придерживайтесь типов, поддерживающих + и <):
>>> 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']
>>>
Увеличьте величину i для цикла, а затем уменьшите ее, когда она вам понадобится.
for i * 100 in range(0, 100, 10):
print i / 100.0
РЕДАКТИРОВАТЬ: я, честно говоря, не могу вспомнить, почему я думал, что это будет работать синтаксически
for i in range(0, 11, 1):
print i / 10.0
Это должно иметь желаемый результат.
scipy имеет встроенную функцию arange который обобщает Python range() конструктор, отвечающий вашим требованиям к обработке чисел с плавающей запятой.
from scipy import arange
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]
(<=> при тестировании меньше шума при округлении).
Аналогично функции R seq, эта функция возвращает последовательность в любом порядке дано правильное значение шага. Последнее значение равно значению остановки.
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]
Встроенная функция range (), я боюсь, возвращает последовательность целочисленных значений, поэтому вы не можете использовать ее для выполнения десятичного шага.
Я бы сказал, просто используйте цикл while:
i = 0.0
while i <= 1.0:
print i
i += 0.1
Если вам интересно, Python конвертирует ваш 0.1 в 0, поэтому он говорит, что аргумент не может быть нулевым.
Вот решение, использующее itertools :
import itertools
def seq(start, end, step):
if step == 0:
raise ValueError("step must not be 0")
sample_count = int(abs(end - start) / step)
return itertools.islice(itertools.count(start, step), sample_count)
Пример использования:
for i in seq(0, 1, 0.1):
print(i)
[x * 0.1 for x in range(0, 10)]
в Python 2.7x дает вам результат:
[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]
import numpy as np
for i in np.arange(0, 1, 0.1):
print i
И если вы делаете это часто, вы можете сохранить сгенерированный список r
r=map(lambda x: x/10.0,range(0,10))
for i in r:
print i
В моих версиях используется исходная функция диапазона для создания мультипликативных индексов для сдвига.Это позволяет использовать тот же синтаксис, что и исходная функция диапазона.Я сделал две версии: одну с плавающей запятой, другую с десятичной, потому что обнаружил, что в некоторых случаях мне хотелось избежать дрейфа округления, вносимого арифметикой с плавающей запятой.
Это согласуется с результатами пустого набора, как в диапазоне/xrange.
Передача только одного числового значения в любую функцию вернет выходной стандартный диапазон к целочисленному максимальному значению входного параметра (поэтому, если вы задали ему 5,5, он вернет диапазон (6).)
Редактировать:приведенный ниже код теперь доступен в виде пакета на pypi: Франжэнс
## 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)) # []
Это мое решение для получения диапазонов с плавающими шагами.
При использовании этой функции нет необходимости ни импортировать, ни устанавливать его.
Я уверен, что это можно улучшить и оптимизировать. Не стесняйтесь делать это и размещать здесь.
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]
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
Вы можете использовать эту функцию:
def frange(start,end,step):
return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))
Чтобы избежать проблемы округления , нужно использовать отдельное число для перемещения по диапазону, который начинается, и наполовину step впереди начало .
# 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.
Для полноты бутика, функциональное решение:
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)
Это можно сделать с помощью библиотеки Numpy. Функция arange () позволяет выполнять шаги в float. Но он возвращает пустой массив, который может быть преобразован в список с помощью tolist () для нашего удобства.
for i in np.arange(0, 1, 0.1).tolist():
print i
Мой ответ похож на другие, использующие map (), без необходимости использования NumPy и без использования лямбды (хотя вы могли бы). Чтобы получить список значений с плавающей запятой от 0,0 до t_max с шагом dt:
def xdt(n):
return dt*float(n)
tlist = map(xdt, range(int(t_max/dt)+1))
Добавить автокоррекцию для возможности неправильного знака на шаге:
def frange(start,step,stop):
step *= 2*((stop>start)^(step<0))-1
return [start+i*step for i in range(int((stop-start)/step))]
Мое решение:
def seq(start, stop, step=1, digit=0):
x = float(start)
v = []
while x <= stop:
v.append(round(x,digit))
x += step
return v
Лучшее решение: нет ошибки округления
_________________________________________________________________________________
>>> 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]
Чтобы реализовать функцию:заменять 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]
start и 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)]
Удивлен, что никто еще не упомянул рекомендуемое решение. в документации Python 3:
Смотрите также:
- А рецепт линспейса показывает, как реализовать ленивую версию диапазона, подходящую для приложений с плавающей запятой.
После определения рецепт прост в использовании и не требует numpy или любые другие внешние библиотеки, но такие функции, как numpy.linspace().Обратите внимание, что вместо step аргумент третий num аргумент указывает количество желаемых значений, например:
print(linspace(0, 10, 5))
# linspace(0, 10, 5)
print(list(linspace(0, 10, 5)))
# [0.0, 2.5, 5.0, 7.5, 10]
Ниже я цитирую модифицированную версию полного рецепта Python 3 от Эндрю Барнерта:
import collections.abc
import numbers
class linspace(collections.abc.Sequence):
"""linspace(start, stop, num) -> linspace object
Return a virtual sequence of num numbers from start to stop (inclusive).
If you need a half-open range, use linspace(start, stop, num+1)[:-1].
"""
def __init__(self, start, stop, num):
if not isinstance(num, numbers.Integral) or num <= 1:
raise ValueError('num must be an integer > 1')
self.start, self.stop, self.num = start, stop, num
self.step = (stop-start)/(num-1)
def __len__(self):
return self.num
def __getitem__(self, i):
if isinstance(i, slice):
return [self[x] for x in range(*i.indices(len(self)))]
if i < 0:
i = self.num + i
if i >= self.num:
raise IndexError('linspace object index out of range')
if i == self.num-1:
return self.stop
return self.start + i*self.step
def __repr__(self):
return '{}({}, {}, {})'.format(type(self).__name__,
self.start, self.stop, self.num)
def __eq__(self, other):
if not isinstance(other, linspace):
return False
return ((self.start, self.stop, self.num) ==
(other.start, other.stop, other.num))
def __ne__(self, other):
return not self==other
def __hash__(self):
return hash((type(self), self.start, self.stop, self.num))
Вот мое решение, которое отлично работает с 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]
Я только новичок, но у меня была такая же проблема при моделировании некоторых вычислений. Вот как я пытался решить эту проблему, которая, кажется, работает с десятичными шагами.
Я также довольно ленив, и поэтому мне было трудно написать свою собственную функцию диапазона.
По сути, я изменил xrange(0.0, 1.0, 0.01) на xrange(0, 100, 1) и использовал деление на 100.0 внутри цикла.
Меня также беспокоило, будут ли ошибки округления. Поэтому я решил проверить, есть ли такие. Теперь я слышал, что если, например, 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 для каждого.
Теперь, если я все понял неправильно, пожалуйста, дайте мне знать.
Этот лайнер не будет загромождать ваш код. Знак параметра step важен.
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)]
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]
