Bereich () für Schwimmer

Ich weiß nicht, eine eingebaute Funktion, aber zu schreiben wie diese sollte nicht zu kompliziert sein.

def frange(x, y, jump):
  while x < y:
    yield x
    x += jump

Als Sie die Kommentare erwähnen, dies könnte zu unvorhersehbaren Ergebnissen führen wie:

>>> list(frange(0, 100, 0.1))[-1]
99.9999999999986

Korrektes Ergebnis zu erhalten, können Sie verwenden Sie eine der anderen Antworten in dieser Frage, oder wie @Tadhg erwähnt, können Sie decimal.Decimal als jump argument. Stellen Sie sicher, dass eine Initialisierung mit einem string statt einem Schwimmer.

>>> import decimal
>>> list(frange(0, 100, decimal.Decimal('0.1')))[-1]
Decimal('99.9')

Oder auch:

import decimal

def drange(x, y, jump):
  while x < y:
    yield float(x)
    x += decimal.Decimal(jump)

Dann:

>>> list(drange(0, 100, '0.1'))[-1]
99.9

InformationsquelleAutor der Antwort kichik

Ich verwendet, um zu verwenden numpy.arange hatte aber einige Komplikationen Kontrolle der Anzahl von Elementen, die es gibt, wegen der floating-point-Fehler. Also ich benutze jetzt linspacez.B.:

>>> import numpy
>>> numpy.linspace(0, 10, num=4)
array([  0.        ,   3.33333333,   6.66666667,  10.        ])

InformationsquelleAutor der Antwort wim

Eifrig ausgewertet (2.x range):

[x * .5 for x in range(10)]

Verzögert ausgewertet (2.x xrange3.x range):

itertools.imap(lambda x: x * .5, xrange(10)) # or range(10) as appropriate

Abwechselnd:

itertools.islice(itertools.imap(lambda x: x * .5, itertools.count()), 10)
# without applying the `islice`, we get an infinite stream of half-integers.

InformationsquelleAutor der Antwort Karl Knechtel

Gibt es keine solche eingebaute Funktion, aber Sie können mit der folgenden (Python-3-code), um den job so sicher wie Python ermöglicht.

from fractions import Fraction

def frange(start, stop, jump, end=False, via_str=False):
    """
    Equivalent of Python 3 range for decimal numbers.

    Notice that, because of arithmetic errors, it is safest to
    pass the arguments as strings, so they can be interpreted to exact fractions.

    >>> assert Fraction('1.1') - Fraction(11, 10) == 0.0
    >>> assert Fraction( 0.1 ) - Fraction(1, 10) == Fraction(1, 180143985094819840)

    Parameter `via_str` can be set to True to transform inputs in strings and then to fractions.
    When inputs are all non-periodic (in base 10), even if decimal, this method is safe as long
    as approximation happens beyond the decimal digits that Python uses for printing.


    For example, in the case of 0.1, this is the case:

    >>> assert str(0.1) == '0.1'
    >>> assert '%.50f' % 0.1 == '0.10000000000000000555111512312578270211815834045410'


    If you are not sure whether your decimal inputs all have this property, you are better off
    passing them as strings. String representations can be in integer, decimal, exponential or
    even fraction notation.

    >>> assert list(frange(1, 100.0, '0.1', end=True))[-1] == 100.0
    >>> assert list(frange(1.0, '100', '1/10', end=True))[-1] == 100.0
    >>> assert list(frange('1', '100.0', '.1', end=True))[-1] == 100.0
    >>> assert list(frange('1.0', 100, '1e-1', end=True))[-1] == 100.0
    >>> assert list(frange(1, 100.0, 0.1, end=True))[-1] != 100.0
    >>> assert list(frange(1, 100.0, 0.1, end=True, via_str=True))[-1] == 100.0

    """
    if via_str:
        start = str(start)
        stop = str(stop)
        jump = str(jump)
    start = Fraction(start)
    stop = Fraction(stop)
    jump = Fraction(jump)
    while start < stop:
        yield float(start)
        start += jump
    if end and start == stop:
        yield(float(start))

Können Sie überprüfen Sie es, indem ein paar Behauptungen:

assert Fraction('1.1') - Fraction(11, 10) == 0.0
assert Fraction( 0.1 ) - Fraction(1, 10) == Fraction(1, 180143985094819840)

assert str(0.1) == '0.1'
assert '%.50f' % 0.1 == '0.10000000000000000555111512312578270211815834045410'

assert list(frange(1, 100.0, '0.1', end=True))[-1] == 100.0
assert list(frange(1.0, '100', '1/10', end=True))[-1] == 100.0
assert list(frange('1', '100.0', '.1', end=True))[-1] == 100.0
assert list(frange('1.0', 100, '1e-1', end=True))[-1] == 100.0
assert list(frange(1, 100.0, 0.1, end=True))[-1] != 100.0
assert list(frange(1, 100.0, 0.1, end=True, via_str=True))[-1] == 100.0

assert list(frange(2, 3, '1/6', end=True))[-1] == 3.0
assert list(frange(0, 100, '1/3', end=True))[-1] == 100.0

Codes auf GitHub

InformationsquelleAutor der Antwort marcotama

Warum Gibt Es Keine Floating-Point-Bereich-Implementierung In Der Standard-Bibliothek?

Als deutlich gemacht, von allen posts hier, es gibt keine floating-point-version von range(). Das heißt, der Verzicht macht Sinn, wenn man bedenkt, dass die range() Funktion wird Häufig verwendet, um einen index (und natürlich, das bedeutet, dass ein accessor) generator. Also, wenn wir rufen range(0,40) sind wir in der Tat sagen, dass wir wollen, dass 40 Werte beginnend bei 0, bis zu 40, aber nicht-inklusive der 40 sich.

Wenn man bedenkt, dass die Generierung von index ist so viel über die Anzahl der Indizes wie es ist, Ihre Werte, die Verwendung eines float-Implementierung von range() in der standard-library macht noch weniger Sinn. Wenn wir zum Beispiel die Funktion aufgerufen frange(0, 10, 0.25) würden wir erwarten, dass beide 0 und 10 enthalten sein, aber das würde die Ausbeute eines Vektors mit 41 Werten.

So, ein frange() Funktion je nach Einsatz wird immer zeigen counter-intuitive Verhalten; entweder es hat zu viele Werte in der Wahrnehmung aus der Indizierung Perspektive oder nicht inklusive ist eine Zahl, die angemessen zurückgegeben werden sollen, die aus der mathematischen Perspektive.

Die Mathematische Use-Case -

Mit sagte, dass, wie bereits erörtert, ist numpy.linspace() führt die generation mit der mathematischen Perspektive schön:

numpy.linspace(0, 10, 41)
array([  0.  ,   0.25,   0.5 ,   0.75,   1.  ,   1.25,   1.5 ,   1.75,
         2.  ,   2.25,   2.5 ,   2.75,   3.  ,   3.25,   3.5 ,   3.75,
         4.  ,   4.25,   4.5 ,   4.75,   5.  ,   5.25,   5.5 ,   5.75,
         6.  ,   6.25,   6.5 ,   6.75,   7.  ,   7.25,   7.5 ,   7.75,
         8.  ,   8.25,   8.5 ,   8.75,   9.  ,   9.25,   9.5 ,   9.75,  10.
])

Die Indizierung Use-Case -

Und für die Indizierung Perspektive, die ich geschrieben habe, einen etwas anderen Ansatz mit einigen tricksy string-Magie, die es uns ermöglicht das angeben der Anzahl der Dezimalstellen.

# Float range function - string formatting method
def frange_S (start, stop, skip = 1.0, decimals = 2):
    for i in range(int(start / skip), int(stop / skip)):
        yield float(("%0." + str(decimals) + "f") % (i * skip))

Ähnlich, wir können auch das eingebaute round Funktion und geben Sie die Anzahl von Dezimalstellen:

# Float range function - rounding method
def frange_R (start, stop, skip = 1.0, decimals = 2):
    for i in range(int(start / skip), int(stop / skip)):
        yield round(i * skip, ndigits = decimals)

Einen Schnellen Vergleich & Leistung

Natürlich, angesichts der obigen Diskussion, diese Funktionen haben eine ziemlich begrenzte Verwendung. Trotzdem, hier ein kurzer Vergleich:

def compare_methods (start, stop, skip):

    string_test  = frange_S(start, stop, skip)
    round_test   = frange_R(start, stop, skip)

    for s, r in zip(string_test, round_test):
        print(s, r)

compare_methods(-2, 10, 1/3)

Die Ergebnisse sind identisch für jeden:

-2.0 -2.0
-1.67 -1.67
-1.33 -1.33
-1.0 -1.0
-0.67 -0.67
-0.33 -0.33
0.0 0.0
...
8.0 8.0
8.33 8.33
8.67 8.67
9.0 9.0
9.33 9.33
9.67 9.67

Und einige timings:

>>> import timeit

>>> setup = """
... def frange_s (start, stop, skip = 1.0, decimals = 2):
...     for i in range(int(start /skip), int(stop /skip)):
...         yield float(("%0." + str(decimals) + "f") % (i * skip))
... def frange_r (start, stop, skip = 1.0, decimals = 2):
...     for i in range(int(start /skip), int(stop /skip)):
...         yield round(i * skip, ndigits = decimals)
... start, stop, skip = -1, 8, 1/3
... """

>>> min(timeit.Timer('string_test = frange_s(start, stop, skip); [x for x in string_test]', setup=setup).repeat(30, 1000))
0.024284090992296115

>>> min(timeit.Timer('round_test = frange_r(start, stop, skip); [x for x in round_test]', setup=setup).repeat(30, 1000))
0.025324633985292166

Sieht aus wie der string-Formatierung Methode gewinnt, indem er ein Haar auf meinem system.

Die Einschränkungen

Und schließlich eine demonstration von dem Punkt aus der Diskussion über und noch eine Letzte Einschränkung:

# "Missing" the last value (10.0)
for x in frange_R(0, 10, 0.25):
    print(x)

0.25
0.5
0.75
1.0
...
9.0
9.25
9.5
9.75

Weiter, wenn die skip parameter ist nicht teilbar durch das stop Wert, kann es eine gähnende Kluft angesichts der letzteren Frage:

# Clearly we know that 10 - 9.43 is equal to 0.57
for x in frange_R(0, 10, 3/7):
    print(x)

0.0
0.43
0.86
1.29
...
8.14
8.57
9.0
9.43

Gibt es Möglichkeiten, um dieses Problem zu beheben, aber am Ende des Tages, der beste Ansatz wäre wohl, nur mit Numpy.

InformationsquelleAutor der Antwort Greenstick

schrieb ich eine Funktion zurückgibt, die ein Tupel von einer Reihe von double-precision-floating-point-zahlen ohne Dezimalstellen über die Hundertstel. es war einfach eine Frage der Analyse der range-Werte wie strings und die Abspaltung der exzess. Ich verwende es für eine Anzeige reicht, um von zu wählen, innerhalb eines UI. Ich hoffe, jemand findet es nützlich.

def drange(start,stop,step):
    double_value_range = []
    while start<stop:
        a = str(start)
        a.split('.')[1].split('0')[0]
        start = float(str(a))
        double_value_range.append(start)
        start = start+step
    double_value_range_tuple = tuple(double_value_range)
   #print double_value_range_tuple
    return double_value_range_tuple

InformationsquelleAutor der Antwort chris mcinnis

Ich denke, dass es eine sehr einfache Antwort, die wirklich emuliert alle Funktionen der Reihe, aber für beide float und integer. In dieser Lösung, Sie einfach annehmen, dass deine Annäherung durch Standardwert ist 1e-7 (oder die, die Sie wählen) und Sie können es ändern, wenn Sie die Funktion aufrufen.

def drange(start,stop=None,jump=1,approx=7): # Approx to 1e-7 by default
  '''
  This function is equivalent to range but for both float and integer
  '''
  if not stop: # If there is no y value: range(x)
      stop= start
      start= 0
  valor= round(start,approx)
  while valor < stop:
      if valor==int(valor):
          yield int(round(valor,approx))
      else:
          yield float(round(valor,approx))
      valor += jump
  for i in drange(12):
      print(i)

InformationsquelleAutor der Antwort Jose Alavedra