Wie verwendet man einen dezimalen Bereich()-Schrittwert?

Question

Gibt es eine Möglichkeit, zwischen 0 und 1 um 0,1 zu wechseln?

Ich dachte, ich könnte es wie folgt machen, aber es hat nicht geklappt:

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

Stattdessen heißt es, dass das Schrittargument nicht Null sein kann, was ich nicht erwartet hatte.

Answer 1

Ich bin nur ein Anfänger, aber ich hatte das gleiche Problem, als ich einige Berechnungen simulierte. Hier ist, wie ich versucht habe, das Problem zu lösen, was mit Dezimalschritten zu funktionieren scheint.

Ich bin auch ziemlich faul, und so fiel es mir schwer, meine eigene Bereichsfunktion zu schreiben.

Im Wesentlichen habe ich meine xrange(0.0, 1.0, 0.01) a xrange(0, 100, 1) und verwendete die Division durch 100.0 innerhalb der Schleife. Ich war auch besorgt, dass es zu Rundungsfehlern kommen könnte. Also beschloss ich zu testen, ob es welche gibt. Nun habe ich gehört, dass wenn zum Beispiel 0.01 aus einer Berechnung ist nicht gerade der Float 0.01 Der Vergleich sollte False ergeben (falls ich mich irre, lassen Sie es mich bitte wissen).

Also beschloss ich, in einem kurzen Test zu prüfen, ob meine Lösung für meinen Bereich geeignet ist:

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

Und es wurde jeweils Wahr gedruckt.

Wenn ich das völlig falsch verstehe, lassen Sie es mich bitte wissen.

Answer 2

Meine Antwort ist ähnlich wie bei anderen, die map() verwenden, ohne NumPy zu benötigen und ohne Lambda zu verwenden (obwohl man das könnte). Um eine Liste von Float-Werten von 0.0 bis t_max in Schritten von dt zu erhalten:

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

Answer 3

Hier ist meine Lösung, die mit float_range(-1, 0, 0.01) gut funktioniert und keine Fehler bei der Fließkommadarstellung aufweist. Es ist nicht sehr schnell, aber funktioniert gut:

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]

Answer 4

Meine Lösung:

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

Answer 5

Fügen Sie eine Autokorrektur für die Möglichkeit einer falschen Unterschrift auf dem Schritt hinzu:

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