Как использовать значение шага десятичного диапазона ()?
есть ли способ сделать шаг между 0 и 1 на 0,1?
Я думал, что смогу сделать это следующим образом, но это не удалось:
for i in range(0, 1, 0.1):
print i
вместо этого он говорит, что аргумент step не может быть равен нулю, чего я не ожидал.
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])
диапазон Python () может делать только целые числа, а не с плавающей точкой. В вашем конкретном случае вместо этого вы можете использовать понимание списка:
[x * 0.1 for x in range(0, 10)]
(замените вызов диапазона этим выражением.)
в более общем случае, вы можете написать пользовательскую функцию или генератор.
дом на ' 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'] >>>
рост величины
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
Это должно иметь желаемый результат.
scipy
имеет встроенную функциюarange
обобщающее языка Pythonrange()
конструктор для того чтобы удовлетворять ваше требование регулировать поплавка.
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]
(
1/x
производил меньше шума округления, когда я тестировал).
аналогично Р
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): 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
[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]
и если вы делаете это часто, вы можете сохранить сгенерированный список
r
r=map(lambda x: x/10.0,range(0,10)) for i in r: print i
мои версии используют исходную функцию диапазона для создания мультипликативных индексов для сдвига. Это позволяет использовать тот же синтаксис для исходной функции диапазона. Я сделал две версии, одну с использованием float, а другую с использованием Decimal, потому что я обнаружил, что в некоторых случаях я хотел избежать дрейфа округления, введенного арифметикой с плавающей запятой.
это согласуется с пустыми результатами набора, как в диапазоне / xrange.
передача только одного числового значения в любую функцию будет возвращает стандартный диапазон вывода к целочисленному значению потолка входного параметра(поэтому, если вы дали ему 5.5, он вернет диапазон (6).)
изменить: приведенный ниже код теперь доступен в виде пакета на 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)) # []
Это мое решение, чтобы получить диапазоны с шагом поплавок.
С помощью этой функции нет необходимости импортировать 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]
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)))
трюк, чтобы избежать проблема округления это использовать отдельный номер для перемещения по диапазону, который начинается и пол the шаг перед start.
# 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. Но, он возвращает массив numpy, который может быть преобразован в список с помощью 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 включены, а не один или другой (обычно 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, Jul 8 2017, 04:57:36) [MSC V. 1900 64 бит (AMD64)]
удивлен, что никто еще не упомянул рекомендуемое решение в Python 3 docs:
Читайте также:
- The рецепт linspace показывает, как реализовать ленивую версию диапазона, которая подходит для приложений с плавающей запятой.
после определения, рецепт прост в использовании и не требует
numpy
или любые другие внешние библиотеки, но функции, такие какnumpy.linspace()
. Заметить что а не
чтобы противостоять вопросам точности поплавка, вы можете использовать
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')]
вот мое решение, которое отлично работает с 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)
toxrange(0, 100, 1)
и использовал деление на100.0
внутри цикла. Я также был обеспокоен, если будут ошибки округления. Поэтому я решил проверить, есть ли любой. Теперь я слышал, что если например0.01
из расчета не поплавок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 для каждого.
теперь, если я получаю это совершенно неправильно, пожалуйста, дайте мне знать.