912

0 と 1 の間を 0.1 ずつステップする方法はありますか?

次のようにできると思ったのですが、失敗しました。

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

代わりに、step 引数をゼロにすることはできないと表示されますが、これは予期していませんでした。

4

34 に答える 34

1124

10 進数のステップを直接使用するよりも、必要なポイント数で表現する方がはるかに安全です。そうしないと、浮動小数点の丸め誤差によって誤った結果が得られる可能性があります。

NumPyライブラリのlinspace関数を使用できます(これは標準ライブラリの一部ではありませんが、比較的簡単に入手できます)。返されるポイントの数を取り、適切なエンドポイントを含めるかどうかを指定することもできます。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])
于 2009-01-25T12:26:08.160 に答える
257

Python の range() は整数のみを処理でき、浮動小数点は処理できません。特定のケースでは、代わりにリスト内包表記を使用できます。

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

( range への呼び出しをその式に置き換えます。)

より一般的なケースでは、カスタム関数またはジェネレーターを作成することができます。

于 2009-01-25T10:35:25.590 に答える
157

'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']
>>>
于 2009-01-25T11:57:17.280 に答える
37

for ループの大きさを増やしてから、i必要に応じて減らします。

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

編集:正直なところ、構文的に機能すると思った理由を思い出せません

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

これにより、目的の出力が得られるはずです。

于 2009-01-25T10:32:01.180 に答える
21

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 ]

于 2012-06-11T19:10:53.020 に答える
15

range() 組み込み関数は一連の整数値を返します。残念ながら、それを使用して 10 進数のステップを実行することはできません。

whileループを使用するだけだと思います：

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

興味がある方のために説明すると、Python は 0.1 を 0 に変換しているため、引数をゼロにすることはできません。

于 2009-01-25T10:32:43.973 に答える
14

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)
于 2012-11-08T10:00:02.017 に答える
12 
[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]

于 2012-05-13T23:20:58.553 に答える
10 
import numpy as np
for i in np.arange(0, 1, 0.1): 
    print i
于 2012-09-07T02:01:56.077 に答える
6

これを頻繁に行う場合は、生成されたリストを保存することをお勧めしますr

r=map(lambda x: x/10.0,range(0,10))
for i in r:
    print i
于 2009-01-25T10:48:33.130 に答える
5

最善の解決策:丸め誤差なし

>>> 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]
于 2016-12-10T19:03:43.813 に答える
4

私のバージョンでは、元の範囲関数を使用して、シフトの乗法インデックスを作成しています。これにより、元の範囲関数と同じ構文が可能になります。float を使用するバージョンと Decimal を使用するバージョンの 2 つのバージョンを作成しました。

range/xrange のように空のセットの結果と一致します。

いずれかの関数に数値を 1 つだけ渡すと、標準範囲の出力が入力パラメーターの整数の上限値に返されます (したがって、5.5 を指定すると、range(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)) # []
于 2012-12-12T22:29:48.793 に答える
3

ブティックの完全性のために、機能的なソリューション:

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)
于 2015-09-12T07:44:22.010 に答える
3

これは、フロート ステップで範囲を取得するための私のソリューションです。
この関数を使用すると、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]
于 2013-12-12T17:04:50.703 に答える
3

ここでの解決策の多くは、Python 3.6 でまだ浮動小数点エラーがあり、私が個人的に必要としていたことを正確に実行しませんでした。

以下の関数は整数または浮動小数点数を取り、インポートを必要とせず、浮動小数点エラーを返しません。

def frange(x, y, step):
    if int(x + y + step) == (x + y + step):
        r = list(range(int(x), int(y), int(step)))
    else:
        f = 10 ** (len(str(step)) - str(step).find('.') - 1)
        rf = list(range(int(x * f), int(y * f), int(step * f)))
        r = [i / f for i in rf]

    return r
于 2019-02-05T18:49:33.600 に答える
2

この機能を使用できます：

def frange(start,end,step):
    return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))
于 2010-06-25T17:57:04.330 に答える
2

Numpy ライブラリを使用して実行できます。arange() 関数は float のステップを許可します。ただし、便宜上、 tolist() を使用してリストに変換できる numpy 配列を返します。

for i in np.arange(0, 1, 0.1).tolist():
   print i
于 2016-02-12T12:18:12.740 に答える
2

ここでのパーティーに遅れていることはわかっていますが、3.6 で動作する簡単なジェネレーター ソリューションを次に示します。

def floatRange(*args):
    start, step = 0, 1
    if len(args) == 1:
        stop = args[0]
    elif len(args) == 2:
        start, stop = args[0], args[1]
    elif len(args) == 3:
        start, stop, step = args[0], args[1], args[2]
    else:
        raise TypeError("floatRange accepts 1, 2, or 3 arguments. ({0} given)".format(len(args)))
    for num in start, step, stop:
        if not isinstance(num, (int, float)):
            raise TypeError("floatRange only accepts float and integer arguments. ({0} : {1} given)".format(type(num), str(num)))
    for x in range(int((stop-start)/step)):
        yield start + (x * step)
    return

その後、元のように呼び出すことができますrange()...エラー処理はありませんが、合理的にキャッチできるエラーがある場合はお知らせください。更新します。または更新できます。これがスタックオーバーフローです。

于 2019-01-02T21:07:20.893 に答える
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]
于 2013-01-08T21:21:33.523 に答える
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))]
于 2010-12-01T06:36:16.003 に答える
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
于 2012-07-25T13:50:47.807 に答える
0

この 1 つのライナーでコードが乱雑になることはありません。ステップパラメータの符号は重要です。

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)]
于 2013-11-20T16:47:50.613 に答える
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]
于 2014-07-10T18:15:39.210 に答える